[omnibox] Migrate to std::make_unique

std::make_unique is preferred over base::MakeUnique, and allows
one less include.

Bug: 
Change-Id: Ibf3f6c1b061d4e53331ff976c0966b0773dcf80f
Reviewed-on: https://chromium-review.googlesource.com/806414
Commit-Queue: Kevin Bailey <krb@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521685}

chrome/browser/autocomplete/autocomplete_classifier_factory.cc

@@ -4,7 +4,8 @@
 
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/autocomplete/contextual_suggestions_service_factory.h"
@@ -39,14 +40,11 @@ AutocompleteClassifierFactory* AutocompleteClassifierFactory::GetInstance() {
 std::unique_ptr<KeyedService> AutocompleteClassifierFactory::BuildInstanceFor(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
-  auto provider_client =
-      base::MakeUnique<ChromeAutocompleteProviderClient>(profile);
-  auto controller = base::MakeUnique<AutocompleteController>(
-      std::move(provider_client), nullptr,
-      AutocompleteClassifier::DefaultOmniboxProviders());
-  return base::MakeUnique<AutocompleteClassifier>(
-      std::move(controller),
-      base::MakeUnique<ChromeAutocompleteSchemeClassifier>(profile));
+  return std::make_unique<AutocompleteClassifier>(
+      std::make_unique<AutocompleteController>(
+          std::make_unique<ChromeAutocompleteProviderClient>(profile), nullptr,
+          AutocompleteClassifier::DefaultOmniboxProviders()),
+      std::make_unique<ChromeAutocompleteSchemeClassifier>(profile));
 }
 
 AutocompleteClassifierFactory::AutocompleteClassifierFactory()

chrome/browser/ui/views/frame/test_with_browser_view.cc

@@ -4,7 +4,8 @@
 
 #include "chrome/browser/ui/views/frame/test_with_browser_view.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
@@ -35,28 +36,24 @@ namespace {
 std::unique_ptr<KeyedService> CreateTemplateURLService(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
-  return base::MakeUnique<TemplateURLService>(
-      profile->GetPrefs(),
-      std::unique_ptr<SearchTermsData>(new UIThreadSearchTermsData(profile)),
+  return std::make_unique<TemplateURLService>(
+      profile->GetPrefs(), std::make_unique<UIThreadSearchTermsData>(profile),
       WebDataServiceFactory::GetKeywordWebDataForProfile(
           profile, ServiceAccessType::EXPLICIT_ACCESS),
-      std::unique_ptr<TemplateURLServiceClient>(
-          new ChromeTemplateURLServiceClient(
-              HistoryServiceFactory::GetForProfile(
-                  profile, ServiceAccessType::EXPLICIT_ACCESS))),
+      std::make_unique<ChromeTemplateURLServiceClient>(
+          HistoryServiceFactory::GetForProfile(
+              profile, ServiceAccessType::EXPLICIT_ACCESS)),
       nullptr, nullptr, base::Closure());
 }
 
 std::unique_ptr<KeyedService> CreateAutocompleteClassifier(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
-  return base::MakeUnique<AutocompleteClassifier>(
-      base::WrapUnique(new AutocompleteController(
-          base::WrapUnique(new ChromeAutocompleteProviderClient(profile)),
-
-          nullptr, AutocompleteClassifier::DefaultOmniboxProviders())),
-      std::unique_ptr<AutocompleteSchemeClassifier>(
-          new TestSchemeClassifier()));
+  return std::make_unique<AutocompleteClassifier>(
+      std::make_unique<AutocompleteController>(
+          std::make_unique<ChromeAutocompleteProviderClient>(profile), nullptr,
+          AutocompleteClassifier::DefaultOmniboxProviders()),
+      std::make_unique<TestSchemeClassifier>());
 }
 
 }  // namespace

components/omnibox/browser/autocomplete_controller.cc

@@ -5,14 +5,15 @@
 #include "components/omnibox/browser/autocomplete_controller.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ -245,7 +246,7 @@ AutocompleteController::AutocompleteController(
     // that would come with it.
     if (!ClipboardRecentContent::GetInstance()) {
       ClipboardRecentContent::SetInstance(
-          base::MakeUnique<ClipboardRecentContentGeneric>());
+          std::make_unique<ClipboardRecentContentGeneric>());
     }
 #endif
     // ClipboardRecentContent can be null in iOS tests.  For non-iOS, we

components/omnibox/browser/autocomplete_provider_unittest.cc

@@ -288,7 +288,7 @@ AutocompleteProviderTest::AutocompleteProviderTest()
     : client_(new AutocompleteProviderClientWithClosure()),
       client_owned_(false) {
   client_->set_template_url_service(
-      base::MakeUnique<TemplateURLService>(nullptr, 0));
+      std::make_unique<TemplateURLService>(nullptr, 0));
 }
 
 AutocompleteProviderTest::~AutocompleteProviderTest() {
@@ -304,7 +304,7 @@ void AutocompleteProviderTest::RegisterTemplateURL(
   data.SetKeyword(keyword);
   TemplateURLService* turl_model = client_->GetTemplateURLService();
   TemplateURL* default_turl =
-      turl_model->Add(base::MakeUnique<TemplateURL>(data));
+      turl_model->Add(std::make_unique<TemplateURL>(data));
   turl_model->SetUserSelectedDefaultSearchProvider(default_turl);
   turl_model->Load();
   TemplateURLID default_provider_id = default_turl->id();
@@ -369,7 +369,7 @@ void AutocompleteProviderTest::ResetControllerWithKeywordAndSearchProviders() {
   data.SetURL("http://defaultturl/{searchTerms}");
   TemplateURLService* turl_model = client_->GetTemplateURLService();
   TemplateURL* default_turl =
-      turl_model->Add(base::MakeUnique<TemplateURL>(data));
+      turl_model->Add(std::make_unique<TemplateURL>(data));
   turl_model->SetUserSelectedDefaultSearchProvider(default_turl);
   TemplateURLID default_provider_id = default_turl->id();
   ASSERT_NE(0, default_provider_id);
@@ -380,7 +380,7 @@ void AutocompleteProviderTest::ResetControllerWithKeywordAndSearchProviders() {
   data2.SetKeyword(base::ASCIIToUTF16("k"));
   data2.SetURL("http://keyword/{searchTerms}");
   TemplateURL* keyword_turl =
-      turl_model->Add(base::MakeUnique<TemplateURL>(data2));
+      turl_model->Add(std::make_unique<TemplateURL>(data2));
   ASSERT_NE(0, keyword_turl->id());
 
   ResetControllerWithType(AutocompleteProvider::TYPE_KEYWORD |
@@ -396,22 +396,22 @@ void AutocompleteProviderTest::ResetControllerWithKeywordProvider() {
   data.SetKeyword(base::ASCIIToUTF16("foo.com"));
   data.SetURL("http://foo.com/{searchTerms}");
   TemplateURL* keyword_turl =
-      turl_model->Add(base::MakeUnique<TemplateURL>(data));
+      turl_model->Add(std::make_unique<TemplateURL>(data));
   ASSERT_NE(0, keyword_turl->id());
 
   // Make a TemplateURL for KeywordProvider that a shorter version of the
   // first.
   data.SetShortName(base::ASCIIToUTF16("f"));
   data.SetKeyword(base::ASCIIToUTF16("f"));
   data.SetURL("http://f.com/{searchTerms}");
-  keyword_turl = turl_model->Add(base::MakeUnique<TemplateURL>(data));
+  keyword_turl = turl_model->Add(std::make_unique<TemplateURL>(data));
   ASSERT_NE(0, keyword_turl->id());
 
   // Create another TemplateURL for KeywordProvider.
   data.SetShortName(base::ASCIIToUTF16("bar.com"));
   data.SetKeyword(base::ASCIIToUTF16("bar.com"));
   data.SetURL("http://bar.com/{searchTerms}");
-  keyword_turl = turl_model->Add(base::MakeUnique<TemplateURL>(data));
+  keyword_turl = turl_model->Add(std::make_unique<TemplateURL>(data));
   ASSERT_NE(0, keyword_turl->id());
 
   ResetControllerWithType(AutocompleteProvider::TYPE_KEYWORD);

components/omnibox/browser/autocomplete_result_unittest.cc

@@ -11,7 +11,6 @@
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -104,7 +103,7 @@ class AutocompleteResultTest : public testing::Test {
     // a DCHECK.
     field_trial_list_.reset();
     field_trial_list_.reset(new base::FieldTrialList(
-        base::MakeUnique<metrics::SHA1EntropyProvider>("foo")));
+        std::make_unique<metrics::SHA1EntropyProvider>("foo")));
     variations::testing::ClearAllVariationParams();
 
     // Create the list of mock providers.  5 is enough.
@@ -542,7 +541,7 @@ TEST_F(AutocompleteResultTest, SortAndCullDuplicateSearchURLs) {
   url_data.SetShortName(base::ASCIIToUTF16("unittest"));
   url_data.SetKeyword(base::ASCIIToUTF16("foo"));
   url_data.SetURL("http://www.foo.com/s?q={searchTerms}");
-  template_url_service_.get()->Add(base::MakeUnique<TemplateURL>(url_data));
+  template_url_service_.get()->Add(std::make_unique<TemplateURL>(url_data));
 
   TestData data[] = {
     { 0, 1, 1300, true },
@@ -586,7 +585,7 @@ TEST_F(AutocompleteResultTest, SortAndCullWithMatchDups) {
   url_data.SetShortName(base::ASCIIToUTF16("unittest"));
   url_data.SetKeyword(base::ASCIIToUTF16("foo"));
   url_data.SetURL("http://www.foo.com/s?q={searchTerms}");
-  template_url_service_.get()->Add(base::MakeUnique<TemplateURL>(url_data));
+  template_url_service_.get()->Add(std::make_unique<TemplateURL>(url_data));
 
   AutocompleteMatch dup_match;
   dup_match.destination_url = GURL("http://www.foo.com/s?q=foo&oq=dup");

components/omnibox/browser/base_search_provider.cc

@@ -8,11 +8,11 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "base/feature_list.h"
 #include "base/i18n/case_conversion.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
@@ -161,7 +161,7 @@ AutocompleteMatch BaseSearchProvider::CreateSearchSuggestion(
 void BaseSearchProvider::DeleteMatch(const AutocompleteMatch& match) {
   DCHECK(match.deletable);
   if (!match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey).empty()) {
-    deletion_handlers_.push_back(base::MakeUnique<SuggestionDeletionHandler>(
+    deletion_handlers_.push_back(std::make_unique<SuggestionDeletionHandler>(
         match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey),
         client_->GetRequestContext(),
         base::Bind(&BaseSearchProvider::OnDeletionComplete,

components/omnibox/browser/base_search_provider_unittest.cc

@@ -5,6 +5,7 @@
 #include "components/omnibox/browser/base_search_provider.h"
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ -92,7 +93,7 @@ class BaseSearchProviderTest : public testing::Test {
 TEST_F(BaseSearchProviderTest, PreserveAnswersWhenDeduplicating) {
   TemplateURLData data;
   data.SetURL("http://foo.com/url?bar={searchTerms}");
-  auto template_url = base::MakeUnique<TemplateURL>(data);
+  auto template_url = std::make_unique<TemplateURL>(data);
 
   TestBaseSearchProvider::MatchMap map;
   base::string16 query = base::ASCIIToUTF16("weather los angeles");
@@ -178,7 +179,7 @@ TEST_F(BaseSearchProviderTest, PreserveAnswersWhenDeduplicating) {
 TEST_F(BaseSearchProviderTest, MatchTailSuggestionProperly) {
   TemplateURLData data;
   data.SetURL("http://foo.com/url?bar={searchTerms}");
-  auto template_url = base::MakeUnique<TemplateURL>(data);
+  auto template_url = std::make_unique<TemplateURL>(data);
 
   AutocompleteInput autocomplete_input(
       base::ASCIIToUTF16("weather"), 7, metrics::OmniboxEventProto::BLANK,

components/omnibox/browser/contextual_suggestions_service.cc

@@ -4,11 +4,11 @@
 
 #include "components/omnibox/browser/contextual_suggestions_service.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ -64,9 +64,9 @@ void AddVariationHeaders(const std::unique_ptr<net::URLFetcher>& fetcher) {
 //
 std::string FormatRequestBodyExperimentalService(
     const std::string& current_url) {
-  auto request = base::MakeUnique<base::DictionaryValue>();
-  auto url_list = base::MakeUnique<base::ListValue>();
-  auto url_entry = base::MakeUnique<base::DictionaryValue>();
+  auto request = std::make_unique<base::DictionaryValue>();
+  auto url_list = std::make_unique<base::ListValue>();
+  auto url_entry = std::make_unique<base::DictionaryValue>();
   url_entry->SetString("url", current_url);
   url_list->Append(std::move(url_entry));
   request->Set("urls", std::move(url_list));
@@ -298,7 +298,7 @@ void ContextualSuggestionsService::CreateExperimentalRequest(
   // Create the oauth2 token fetcher.
   const OAuth2TokenService::ScopeSet scopes{
       "https://www.googleapis.com/auth/cusco-chrome-extension"};
-  token_fetcher_ = base::MakeUnique<AccessTokenFetcher>(
+  token_fetcher_ = std::make_unique<AccessTokenFetcher>(
       "contextual_suggestions_service", signin_manager_, token_service_, scopes,
       base::BindOnce(&ContextualSuggestionsService::AccessTokenAvailable,
                      base::Unretained(this), std::move(fetcher),

components/omnibox/browser/fake_autocomplete_provider_client.cc

@@ -4,8 +4,9 @@
 
 #include "components/omnibox/browser/fake_autocomplete_provider_client.h"
 
+#include <memory>
+
 #include "base/files/file_path.h"
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/test_bookmark_client.h"

components/omnibox/browser/history_url_provider_unittest.cc

@@ -11,7 +11,6 @@
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -964,7 +963,7 @@ TEST_F(HistoryURLProviderTest, CullSearchResults) {
   data.SetURL("http://testsearch.com/?q={searchTerms}");
   TemplateURLService* template_url_service = client_->GetTemplateURLService();
   TemplateURL* template_url =
-      template_url_service->Add(base::MakeUnique<TemplateURL>(data));
+      template_url_service->Add(std::make_unique<TemplateURL>(data));
   template_url_service->SetUserSelectedDefaultSearchProvider(template_url);
   template_url_service->Load();
 
@@ -1194,7 +1193,7 @@ TEST_F(HistoryURLProviderTest, MatchURLFormatting) {
   ExpectFormattedFullMatch("abc", L"https://www.abc.def.com/path", 12, 3);
   ExpectFormattedFullMatch("hij", L"https://www.hij.com/path", 12, 3);
 
-  auto feature_list = base::MakeUnique<base::test::ScopedFeatureList>();
+  auto feature_list = std::make_unique<base::test::ScopedFeatureList>();
   feature_list->InitWithFeatures(
       {omnibox::kUIExperimentHideSuggestionUrlScheme,
        omnibox::kUIExperimentHideSuggestionUrlTrivialSubdomains,

components/omnibox/browser/in_memory_url_index_unittest.cc

@@ -17,7 +17,6 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/case_conversion.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
@@ -278,7 +277,7 @@ void InMemoryURLIndexTest::SetUp() {
   }
 
   // Set up a simple template URL service with a default search engine.
-  template_url_service_ = base::MakeUnique<TemplateURLService>(
+  template_url_service_ = std::make_unique<TemplateURLService>(
       kTemplateURLData, arraysize(kTemplateURLData));
   TemplateURL* template_url = template_url_service_->GetTemplateURLForKeyword(
       base::ASCIIToUTF16(kDefaultTemplateURLKeyword));

components/omnibox/browser/keyword_provider_unittest.cc

@@ -7,11 +7,11 @@
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/utf_string_conversions.h"
@@ -66,7 +66,7 @@ class KeywordProviderTest : public testing::Test {
     // a DCHECK.
     field_trial_list_.reset();
     field_trial_list_.reset(new base::FieldTrialList(
-        base::MakeUnique<metrics::SHA1EntropyProvider>("foo")));
+        std::make_unique<metrics::SHA1EntropyProvider>("foo")));
     variations::testing::ClearAllVariationParams();
   }
   ~KeywordProviderTest() override {}
@@ -465,7 +465,7 @@ TEST_F(KeywordProviderTest, AddKeyword) {
   data.SetKeyword(keyword);
   data.SetURL("http://www.google.com/foo?q={searchTerms}");
   TemplateURL* template_url = client_->GetTemplateURLService()->Add(
-      base::MakeUnique<TemplateURL>(data));
+      std::make_unique<TemplateURL>(data));
   ASSERT_TRUE(
       template_url ==
       client_->GetTemplateURLService()->GetTemplateURLForKeyword(keyword));

components/omnibox/browser/mock_autocomplete_provider_client.cc

@@ -4,11 +4,11 @@
 
 #include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
 
 MockAutocompleteProviderClient::MockAutocompleteProviderClient() {
   contextual_suggestions_service_ =
-      base::MakeUnique<ContextualSuggestionsService>(
+      std::make_unique<ContextualSuggestionsService>(
           /*signin_manager=*/nullptr, /*token_service=*/nullptr,
           GetRequestContext());
 }