Remove usage of std::unique_ptr(new...) pattern in components/translate

This CL removes usage of the |new| operator with std::unique_ptr in
components/translate, either changing the call site to use
std::make_unique, or refactoring the call site to not require a
std::unique_ptr at all.

Bug: 881807
Change-Id: I7d66f206bc9807e5188f22b58647901d720d3505
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2341177Reviewed-by: Megan Jablonski <megjablon@chromium.org>
Commit-Queue: Scott Little <sclittle@chromium.org>
Auto-Submit: Scott Little <sclittle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795945}

components/translate/content/renderer/translate_agent.cc

@@ -4,6 +4,7 @@
 
 #include "components/translate/content/renderer/translate_agent.h"
 
+#include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ -230,10 +231,13 @@ std::string TranslateAgent::ExecuteScriptAndGetStringResult(
   }
 
   v8::Local<v8::String> v8_str = result.As<v8::String>();
-  int length = v8_str->Utf8Length(isolate) + 1;
-  std::unique_ptr<char[]> str(new char[length]);
-  v8_str->WriteUtf8(isolate, str.get(), length);
-  return std::string(str.get());
+  int length = v8_str->Utf8Length(isolate);
+  if (length <= 0)
+    return std::string();
+
+  std::string str(static_cast<size_t>(length), '\0');
+  v8_str->WriteUtf8(isolate, &str[0], length);
+  return str;
 }
 
 double TranslateAgent::ExecuteScriptAndGetDoubleResult(

components/translate/core/browser/language_state_unittest.cc

@@ -4,8 +4,6 @@
 
 #include "components/translate/core/browser/language_state.h"
 
-#include <memory>
-
 #include "base/macros.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/translate/core/browser/mock_translate_driver.h"
@@ -17,8 +15,8 @@ using translate::testing::MockTranslateDriver;
 namespace translate {
 
 TEST(LanguageStateTest, IsPageTranslated) {
-  std::unique_ptr<MockTranslateDriver> driver(new MockTranslateDriver);
-  LanguageState language_state(driver.get());
+  MockTranslateDriver driver;
+  LanguageState language_state(&driver);
   EXPECT_FALSE(language_state.IsPageTranslated());
 
   // Navigate to a French page.
@@ -41,36 +39,36 @@ TEST(LanguageStateTest, IsPageTranslated) {
 }
 
 TEST(LanguageStateTest, Driver) {
-  std::unique_ptr<MockTranslateDriver> driver(new MockTranslateDriver);
-  LanguageState language_state(driver.get());
+  MockTranslateDriver driver;
+  LanguageState language_state(&driver);
 
   // Enable/Disable translate.
   EXPECT_FALSE(language_state.translate_enabled());
-  EXPECT_FALSE(driver->on_translate_enabled_changed_called());
+  EXPECT_FALSE(driver.on_translate_enabled_changed_called());
   language_state.SetTranslateEnabled(true);
   EXPECT_TRUE(language_state.translate_enabled());
-  EXPECT_TRUE(driver->on_translate_enabled_changed_called());
+  EXPECT_TRUE(driver.on_translate_enabled_changed_called());
 
-  driver->Reset();
+  driver.Reset();
   language_state.SetTranslateEnabled(false);
   EXPECT_FALSE(language_state.translate_enabled());
-  EXPECT_TRUE(driver->on_translate_enabled_changed_called());
+  EXPECT_TRUE(driver.on_translate_enabled_changed_called());
 
   // Navigate to a French page.
-  driver->Reset();
+  driver.Reset();
   language_state.LanguageDetermined("fr", true);
   EXPECT_FALSE(language_state.translate_enabled());
-  EXPECT_FALSE(driver->on_is_page_translated_changed_called());
-  EXPECT_FALSE(driver->on_translate_enabled_changed_called());
+  EXPECT_FALSE(driver.on_is_page_translated_changed_called());
+  EXPECT_FALSE(driver.on_translate_enabled_changed_called());
 
   // Translate.
   language_state.SetCurrentLanguage("en");
   EXPECT_TRUE(language_state.IsPageTranslated());
-  EXPECT_TRUE(driver->on_is_page_translated_changed_called());
+  EXPECT_TRUE(driver.on_is_page_translated_changed_called());
 
   // Translate feature must be enabled after an actual translation.
   EXPECT_TRUE(language_state.translate_enabled());
-  EXPECT_TRUE(driver->on_translate_enabled_changed_called());
+  EXPECT_TRUE(driver.on_translate_enabled_changed_called());
 }
 
 }  // namespace translate

components/translate/core/browser/translate_download_manager.cc

@@ -17,8 +17,8 @@ TranslateDownloadManager* TranslateDownloadManager::GetInstance() {
 }
 
 TranslateDownloadManager::TranslateDownloadManager()
-    : language_list_(new TranslateLanguageList),
-      script_(new TranslateScript) {}
+    : language_list_(std::make_unique<TranslateLanguageList>()),
+      script_(std::make_unique<TranslateScript>()) {}
 
 TranslateDownloadManager::~TranslateDownloadManager() {}
 
@@ -71,8 +71,8 @@ void TranslateDownloadManager::ClearTranslateScriptForTesting() {
 
 void TranslateDownloadManager::ResetForTesting() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  language_list_.reset(new TranslateLanguageList);
-  script_.reset(new TranslateScript);
+  language_list_ = std::make_unique<TranslateLanguageList>();
+  script_ = std::make_unique<TranslateScript>();
   url_loader_factory_ = nullptr;
 }
 

components/translate/core/browser/translate_prefs_unittest.cc

@@ -66,33 +66,32 @@ static void ExpectEqualLanguageLists(
 
 class TranslatePrefsTest : public testing::Test {
  protected:
-  TranslatePrefsTest()
-      : prefs_(new sync_preferences::TestingPrefServiceSyncable()) {
-    language::LanguagePrefs::RegisterProfilePrefs(prefs_->registry());
-    TranslatePrefs::RegisterProfilePrefs(prefs_->registry());
+  TranslatePrefsTest() {
+    language::LanguagePrefs::RegisterProfilePrefs(prefs_.registry());
+    TranslatePrefs::RegisterProfilePrefs(prefs_.registry());
     translate_prefs_ = std::make_unique<translate::TranslatePrefs>(
-        prefs_.get(), kAcceptLanguagesPref, kPreferredLanguagesPref);
+        &prefs_, kAcceptLanguagesPref, kPreferredLanguagesPref);
     now_ = base::Time::Now();
     two_days_ago_ = now_ - base::TimeDelta::FromDays(2);
   }
 
   void SetUp() override {
-    prefs_->SetString(kAcceptLanguagesPref, std::string());
+    prefs_.SetString(kAcceptLanguagesPref, std::string());
 #if defined(OS_CHROMEOS)
-    prefs_->SetString(kPreferredLanguagesPref, std::string());
+    prefs_.SetString(kPreferredLanguagesPref, std::string());
 #endif
-    prefs_->registry()->RegisterBooleanPref(
+    prefs_.registry()->RegisterBooleanPref(
         prefs::kOfferTranslateEnabled, true,
         user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   }
 
   void SetLastDeniedTime(const std::string& language, base::Time time) {
-    DenialTimeUpdate update(prefs_.get(), language, 2);
+    DenialTimeUpdate update(&prefs_, language, 2);
     update.AddDenialTime(time);
   }
 
   base::Time GetLastDeniedTime(const std::string& language) {
-    DenialTimeUpdate update(prefs_.get(), language, 2);
+    DenialTimeUpdate update(&prefs_, language, 2);
     return update.GetOldestDenialTime();
   }
 
@@ -101,15 +100,15 @@ class TranslatePrefsTest : public testing::Test {
   void ExpectLanguagePrefs(const std::string& expected,
                            const std::string& expected_chromeos) const {
     if (expected.empty()) {
-      EXPECT_TRUE(prefs_->GetString(kAcceptLanguagesPref).empty());
+      EXPECT_TRUE(prefs_.GetString(kAcceptLanguagesPref).empty());
     } else {
-      EXPECT_EQ(expected, prefs_->GetString(kAcceptLanguagesPref));
+      EXPECT_EQ(expected, prefs_.GetString(kAcceptLanguagesPref));
     }
 #if defined(OS_CHROMEOS)
     if (expected_chromeos.empty()) {
-      EXPECT_TRUE(prefs_->GetString(kPreferredLanguagesPref).empty());
+      EXPECT_TRUE(prefs_.GetString(kPreferredLanguagesPref).empty());
     } else {
-      EXPECT_EQ(expected_chromeos, prefs_->GetString(kPreferredLanguagesPref));
+      EXPECT_EQ(expected_chromeos, prefs_.GetString(kPreferredLanguagesPref));
     }
 #endif
   }
@@ -123,7 +122,7 @@ class TranslatePrefsTest : public testing::Test {
   void ExpectBlockedLanguageListContent(
       const std::vector<std::string>& list) const {
     const base::ListValue* const blacklist =
-        prefs_->GetList(kTranslateBlockedLanguagesPref);
+        prefs_.GetList(kTranslateBlockedLanguagesPref);
     ExpectEqualLanguageLists(*blacklist, list);
   }
 
@@ -164,7 +163,7 @@ class TranslatePrefsTest : public testing::Test {
     return result;
   }
 
-  std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> prefs_;
+  sync_preferences::TestingPrefServiceSyncable prefs_;
   std::unique_ptr<translate::TranslatePrefs> translate_prefs_;
 
   // Shared time constants.
@@ -216,14 +215,14 @@ TEST_F(TranslatePrefsTest, UpdateLastDeniedTime) {
 
 // Test that the default value for non-existing entries is base::Time::Null().
 TEST_F(TranslatePrefsTest, DenialTimeUpdate_DefaultTimeIsNull) {
-  DenialTimeUpdate update(prefs_.get(), kTestLanguage, 2);
+  DenialTimeUpdate update(&prefs_, kTestLanguage, 2);
   EXPECT_TRUE(update.GetOldestDenialTime().is_null());
 }
 
 // Test that non-existing entries automatically create a ListValue.
 TEST_F(TranslatePrefsTest, DenialTimeUpdate_ForceListExistence) {
   DictionaryPrefUpdate dict_update(
-      prefs_.get(), TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage);
+      &prefs_, TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage);
   base::DictionaryValue* denial_dict = dict_update.Get();
   EXPECT_TRUE(denial_dict);
 
@@ -232,7 +231,7 @@ TEST_F(TranslatePrefsTest, DenialTimeUpdate_ForceListExistence) {
   EXPECT_FALSE(has_list);
 
   // Calling GetDenialTimes will force creation of a properly populated list.
-  DenialTimeUpdate update(prefs_.get(), kTestLanguage, 2);
+  DenialTimeUpdate update(&prefs_, kTestLanguage, 2);
   base::ListValue* time_list = update.GetDenialTimes();
   EXPECT_TRUE(time_list);
   EXPECT_EQ(0U, time_list->GetSize());
@@ -243,7 +242,7 @@ TEST_F(TranslatePrefsTest, DenialTimeUpdate_ForceListExistence) {
 TEST_F(TranslatePrefsTest, DenialTimeUpdate_Migrate) {
   translate_prefs_->ResetDenialState();
   DictionaryPrefUpdate dict_update(
-      prefs_.get(), TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage);
+      &prefs_, TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage);
   base::DictionaryValue* denial_dict = dict_update.Get();
   EXPECT_TRUE(denial_dict);
   denial_dict->SetDouble(kTestLanguage, two_days_ago_.ToJsTime());
@@ -253,7 +252,7 @@ TEST_F(TranslatePrefsTest, DenialTimeUpdate_Migrate) {
   EXPECT_FALSE(has_list);
 
   // Calling GetDenialTimes will force creation of a properly populated list.
-  DenialTimeUpdate update(prefs_.get(), kTestLanguage, 2);
+  DenialTimeUpdate update(&prefs_, kTestLanguage, 2);
   base::ListValue* time_list = update.GetDenialTimes();
   EXPECT_TRUE(time_list);
 
@@ -265,7 +264,7 @@ TEST_F(TranslatePrefsTest, DenialTimeUpdate_Migrate) {
 }
 
 TEST_F(TranslatePrefsTest, DenialTimeUpdate_SlidingWindow) {
-  DenialTimeUpdate update(prefs_.get(), kTestLanguage, 4);
+  DenialTimeUpdate update(&prefs_, kTestLanguage, 4);
 
   update.AddDenialTime(now_ - base::TimeDelta::FromMinutes(5));
   EXPECT_EQ(update.GetOldestDenialTime(),
@@ -958,12 +957,12 @@ TEST_F(TranslatePrefsTest, DefaultBlockedLanguages) {
 }
 
 TEST_F(TranslatePrefsTest, CanTranslateLanguage) {
-  prefs_->SetString(kAcceptLanguagesPref, "en");
+  prefs_.SetString(kAcceptLanguagesPref, "en");
   TranslateDownloadManager::GetInstance()->set_application_locale("en");
 
   translate_prefs_->ResetToDefaults();
 
-  TranslateAcceptLanguages translate_accept_languages(prefs_.get(),
+  TranslateAcceptLanguages translate_accept_languages(&prefs_,
                                                       kAcceptLanguagesPref);
 
   // Unblocked language.
@@ -991,8 +990,8 @@ TEST_F(TranslatePrefsTest, CanTranslateLanguage) {
 }
 
 TEST_F(TranslatePrefsTest, ForceTriggerOnEnglishPagesCount) {
-  prefs_->SetInteger(kForceTriggerTranslateCountPref,
-                     std::numeric_limits<int>::max() - 1);
+  prefs_.SetInteger(kForceTriggerTranslateCountPref,
+                    std::numeric_limits<int>::max() - 1);
   EXPECT_EQ(std::numeric_limits<int>::max() - 1,
             translate_prefs_->GetForceTriggerOnEnglishPagesCount());
 

components/translate/core/browser/translate_script.cc

@@ -120,7 +120,7 @@ GURL TranslateScript::GetTranslateScriptURL() {
 
 void TranslateScript::OnScriptFetchComplete(bool success,
                                             const std::string& data) {
-  std::unique_ptr<const TranslateURLFetcher> delete_ptr(fetcher_.release());
+  std::unique_ptr<const TranslateURLFetcher> delete_ptr(std::move(fetcher_));
 
   if (success) {
     DCHECK(data_.empty());

components/translate/ios/browser/translate_controller_unittest.mm

@@ -26,8 +26,8 @@ class TranslateControllerTest : public PlatformTest,
                                 public TranslateController::Observer {
  protected:
   TranslateControllerTest()
-      : test_web_state_(new web::TestWebState),
-        test_browser_state_(new web::TestBrowserState),
+      : test_web_state_(std::make_unique<web::TestWebState>()),
+        test_browser_state_(std::make_unique<web::TestBrowserState>()),
         fake_main_frame_(/*frame_id=*/"", /*is_main_frame=*/true, GURL()),
         fake_iframe_(/*frame_id=*/"", /*is_main_frame=*/false, GURL()),
         error_type_(TranslateErrors::Type::NONE),