Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/omnibox/omnibox_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/extensions/api/omnibox.h"
 #include "chrome/common/extensions/api/omnibox/omnibox_handler.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
@@ skipping 26 matching lines @@
 static const int kOmniboxIconPaddingLeft = 2;
 static const int kOmniboxIconPaddingRight = 2;
 #elif defined(OS_MACOSX)
 static const int kOmniboxIconPaddingLeft = 0;
 static const int kOmniboxIconPaddingRight = 2;
 #else
 static const int kOmniboxIconPaddingLeft = 0;
 static const int kOmniboxIconPaddingRight = 0;
 #endif
 
-scoped_ptr<omnibox::SuggestResult> GetOmniboxDefaultSuggestion(
+std::unique_ptr<omnibox::SuggestResult> GetOmniboxDefaultSuggestion(
     Profile* profile,
     const std::string& extension_id) {
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
 
-  scoped_ptr<omnibox::SuggestResult> suggestion;
+  std::unique_ptr<omnibox::SuggestResult> suggestion;
   const base::DictionaryValue* dict = NULL;
   if (prefs && prefs->ReadPrefAsDictionary(extension_id,
                                            kOmniboxDefaultSuggestion,
                                            &dict)) {
     suggestion.reset(new omnibox::SuggestResult);
     omnibox::SuggestResult::Populate(*dict, suggestion.get());
   }
   return suggestion;
 }
 
 // Tries to set the omnibox default suggestion; returns true on success or
 // false on failure.
 bool SetOmniboxDefaultSuggestion(
     Profile* profile,
     const std::string& extension_id,
     const omnibox::DefaultSuggestResult& suggestion) {
   ExtensionPrefs* prefs = ExtensionPrefs::Get(profile);
   if (!prefs)
     return false;
 
-  scoped_ptr<base::DictionaryValue> dict = suggestion.ToValue();
+  std::unique_ptr<base::DictionaryValue> dict = suggestion.ToValue();
   // Add the content field so that the dictionary can be used to populate an
   // omnibox::SuggestResult.
   dict->SetWithoutPathExpansion(kSuggestionContent, new base::StringValue(""));
   prefs->UpdateExtensionPref(extension_id,
                              kOmniboxDefaultSuggestion,
                              dict.release());
 
   return true;
 }
 
 // Returns a string used as a template URL string of the extension.
 std::string GetTemplateURLStringForExtension(const std::string& extension_id) {
   // This URL is not actually used for navigation. It holds the extension's ID.
   return std::string(extensions::kExtensionScheme) + "://" +
       extension_id + "/?q={searchTerms}";
 }
 
 }  // namespace
 
 // static
 void ExtensionOmniboxEventRouter::OnInputStarted(
     Profile* profile, const std::string& extension_id) {
-  scoped_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_STARTED,
-                                    omnibox::OnInputStarted::kEventName,
-                                    make_scoped_ptr(new base::ListValue())));
+  std::unique_ptr<Event> event(new Event(
+      events::OMNIBOX_ON_INPUT_STARTED, omnibox::OnInputStarted::kEventName,
+      base::WrapUnique(new base::ListValue())));
   event->restrict_to_browser_context = profile;
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 // static
 bool ExtensionOmniboxEventRouter::OnInputChanged(
     Profile* profile, const std::string& extension_id,
     const std::string& input, int suggest_id) {
   EventRouter* event_router = EventRouter::Get(profile);
   if (!event_router->ExtensionHasEventListener(
           extension_id, omnibox::OnInputChanged::kEventName))
     return false;
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Set(0, new base::StringValue(input));
   args->Set(1, new base::FundamentalValue(suggest_id));
 
-  scoped_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_CHANGED,
-                                    omnibox::OnInputChanged::kEventName,
-                                    std::move(args)));
+  std::unique_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_CHANGED,
+                                         omnibox::OnInputChanged::kEventName,
+                                         std::move(args)));
   event->restrict_to_browser_context = profile;
   event_router->DispatchEventToExtension(extension_id, std::move(event));
   return true;
 }
 
 // static
 void ExtensionOmniboxEventRouter::OnInputEntered(
     content::WebContents* web_contents,
     const std::string& extension_id,
     const std::string& input,
     WindowOpenDisposition disposition) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   const Extension* extension =
       ExtensionRegistry::Get(profile)->enabled_extensions().GetByID(
           extension_id);
   CHECK(extension);
   extensions::TabHelper::FromWebContents(web_contents)->
       active_tab_permission_granter()->GrantIfRequested(extension);
 
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Set(0, new base::StringValue(input));
   if (disposition == NEW_FOREGROUND_TAB)
     args->Set(1, new base::StringValue(kForegroundTabDisposition));
   else if (disposition == NEW_BACKGROUND_TAB)
     args->Set(1, new base::StringValue(kBackgroundTabDisposition));
   else
     args->Set(1, new base::StringValue(kCurrentTabDisposition));
 
-  scoped_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_ENTERED,
-                                    omnibox::OnInputEntered::kEventName,
-                                    std::move(args)));
+  std::unique_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_ENTERED,
+                                         omnibox::OnInputEntered::kEventName,
+                                         std::move(args)));
   event->restrict_to_browser_context = profile;
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED,
       content::Source<Profile>(profile),
       content::NotificationService::NoDetails());
 }
 
 // static
 void ExtensionOmniboxEventRouter::OnInputCancelled(
     Profile* profile, const std::string& extension_id) {
-  scoped_ptr<Event> event(new Event(events::OMNIBOX_ON_INPUT_CANCELLED,
-                                    omnibox::OnInputCancelled::kEventName,
-                                    make_scoped_ptr(new base::ListValue())));
+  std::unique_ptr<Event> event(new Event(
+      events::OMNIBOX_ON_INPUT_CANCELLED, omnibox::OnInputCancelled::kEventName,
+      base::WrapUnique(new base::ListValue())));
   event->restrict_to_browser_context = profile;
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 OmniboxAPI::OmniboxAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)),
       url_service_(TemplateURLServiceFactory::GetForProfile(profile_)),
       extension_registry_observer_(this) {
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
@@ skipping 87 matching lines @@
 }
 
 template <>
 void BrowserContextKeyedAPIFactory<OmniboxAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ExtensionPrefsFactory::GetInstance());
   DependsOn(TemplateURLServiceFactory::GetInstance());
 }
 
 bool OmniboxSendSuggestionsFunction::RunSync() {
-  scoped_ptr<SendSuggestions::Params> params(
+  std::unique_ptr<SendSuggestions::Params> params(
       SendSuggestions::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
       content::Source<Profile>(GetProfile()->GetOriginalProfile()),
       content::Details<SendSuggestions::Params>(params.get()));
 
   return true;
 }
 
 bool OmniboxSetDefaultSuggestionFunction::RunSync() {
-  scoped_ptr<SetDefaultSuggestion::Params> params(
+  std::unique_ptr<SetDefaultSuggestion::Params> params(
       SetDefaultSuggestion::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (SetOmniboxDefaultSuggestion(
           GetProfile(), extension_id(), params->suggestion)) {
     content::NotificationService::current()->Notify(
         extensions::NOTIFICATION_EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED,
         content::Source<Profile>(GetProfile()->GetOriginalProfile()),
         content::NotificationService::NoDetails());
   }
@@ skipping 51 matching lines @@
   return match_classifications;
 }
 
 void ApplyDefaultSuggestionForExtensionKeyword(
     Profile* profile,
     const TemplateURL* keyword,
     const base::string16& remaining_input,
     AutocompleteMatch* match) {
   DCHECK(keyword->GetType() == TemplateURL::OMNIBOX_API_EXTENSION);
 
-  scoped_ptr<omnibox::SuggestResult> suggestion(
+  std::unique_ptr<omnibox::SuggestResult> suggestion(
       GetOmniboxDefaultSuggestion(profile, keyword->GetExtensionId()));
   if (!suggestion || suggestion->description.empty())
     return;  // fall back to the universal default
 
   const base::string16 kPlaceholderText(base::ASCIIToUTF16("%s"));
   const base::string16 kReplacementText(base::ASCIIToUTF16("<input>"));
 
   base::string16 description = base::UTF8ToUTF16(suggestion->description);
   ACMatchClassifications& description_styles = match->contents_class;
   description_styles = StyleTypesToACMatchClassifications(*suggestion);
 
   // Replace "%s" with the user's input and adjust the style offsets to the
   // new length of the description.
   size_t placeholder(description.find(kPlaceholderText, 0));
   if (placeholder != base::string16::npos) {
     base::string16 replacement =
         remaining_input.empty() ? kReplacementText : remaining_input;
     description.replace(placeholder, kPlaceholderText.length(), replacement);
 
     for (size_t i = 0; i < description_styles.size(); ++i) {
       if (description_styles[i].offset > placeholder)
         description_styles[i].offset += replacement.length() - 2;
     }
   }
 
   match->contents.assign(description);
 }
 
 }  // namespace extensions