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

chrome/browser/extensions/api/declarative_content/content_action.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/declarative_content/content_action.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/invalidate_type.h"
@@ skipping 26 matching lines @@
 //
 // The following are concrete actions.
 //
 
 // Action that instructs to show an extension's page action.
 class ShowPageAction : public ContentAction {
  public:
   ShowPageAction() {}
   ~ShowPageAction() override {}
 
-  static scoped_ptr<ContentAction> Create(
+  static std::unique_ptr<ContentAction> Create(
       content::BrowserContext* browser_context,
       const Extension* extension,
       const base::DictionaryValue* dict,
       std::string* error) {
     // We can't show a page action if the extension doesn't have one.
     if (ActionInfo::GetPageActionInfo(extension) == NULL) {
       *error = kNoPageAction;
-      return scoped_ptr<ContentAction>();
+      return std::unique_ptr<ContentAction>();
     }
-    return make_scoped_ptr(new ShowPageAction);
+    return base::WrapUnique(new ShowPageAction);
   }
 
   // Implementation of ContentAction:
   void Apply(const ApplyInfo& apply_info) const override {
     ExtensionAction* action =
         GetPageAction(apply_info.browser_context, apply_info.extension);
     action->DeclarativeShow(ExtensionTabUtil::GetTabId(apply_info.tab));
     ExtensionActionAPI::Get(apply_info.browser_context)->NotifyChange(
         action, apply_info.tab, apply_info.browser_context);
   }
@@ skipping 19 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ShowPageAction);
 };
 
 // Action that sets an extension's action icon.
 class SetIcon : public ContentAction {
  public:
   SetIcon(const gfx::Image& icon, ActionInfo::Type action_type)
       : icon_(icon), action_type_(action_type) {}
   ~SetIcon() override {}
 
-  static scoped_ptr<ContentAction> Create(
+  static std::unique_ptr<ContentAction> Create(
       content::BrowserContext* browser_context,
       const Extension* extension,
       const base::DictionaryValue* dict,
       std::string* error);
 
   // Implementation of ContentAction:
   void Apply(const ApplyInfo& apply_info) const override {
     Profile* profile = Profile::FromBrowserContext(apply_info.browser_context);
     ExtensionAction* action = GetExtensionAction(profile,
                                                  apply_info.extension);
@@ skipping 57 matching lines @@
     }
   }
 
   return true;
 }
 
 struct ContentActionFactory {
   // Factory methods for ContentAction instances. |extension| is the extension
   // for which the action is being created. |dict| contains the json dictionary
   // that describes the action. |error| is used to return error messages.
-  using FactoryMethod = scoped_ptr<ContentAction>(*)(
+  using FactoryMethod = std::unique_ptr<ContentAction> (*)(
       content::BrowserContext* /* browser_context */,
       const Extension* /* extension */,
       const base::DictionaryValue* /* dict */,
       std::string* /* error */);
   // Maps the name of a declarativeContent action type to the factory
   // function creating it.
   std::map<std::string, FactoryMethod> factory_methods;
 
   ContentActionFactory() {
     factory_methods[keys::kShowPageAction] =
@@ skipping 23 matching lines @@
   bool all_frames;
   bool match_about_blank;
 };
 
 RequestContentScript::ScriptData::ScriptData()
     : all_frames(false),
       match_about_blank(false) {}
 RequestContentScript::ScriptData::~ScriptData() {}
 
 // static
-scoped_ptr<ContentAction> RequestContentScript::Create(
+std::unique_ptr<ContentAction> RequestContentScript::Create(
     content::BrowserContext* browser_context,
     const Extension* extension,
     const base::DictionaryValue* dict,
     std::string* error) {
   ScriptData script_data;
   if (!InitScriptData(dict, error, &script_data))
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
 
-  return make_scoped_ptr(new RequestContentScript(browser_context, extension,
-                                                  script_data));
+  return base::WrapUnique(
+      new RequestContentScript(browser_context, extension, script_data));
 }
 
 // static
-scoped_ptr<ContentAction> RequestContentScript::CreateForTest(
+std::unique_ptr<ContentAction> RequestContentScript::CreateForTest(
     DeclarativeUserScriptMaster* master,
     const Extension* extension,
     const base::Value& json_action,
     std::string* error) {
   // Simulate ContentAction-level initialization. Check that instance type is
   // RequestContentScript.
   error->clear();
   const base::DictionaryValue* action_dict = NULL;
   std::string instance_type;
   if (!(json_action.GetAsDictionary(&action_dict) &&
         action_dict->GetString(keys::kInstanceType, &instance_type) &&
         instance_type == std::string(keys::kRequestContentScript)))
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
 
   // Normal RequestContentScript data initialization.
   ScriptData script_data;
   if (!InitScriptData(action_dict, error, &script_data))
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
 
   // Inject provided DeclarativeUserScriptMaster, rather than looking it up
   // using a BrowserContext.
-  return make_scoped_ptr(new RequestContentScript(master, extension,
-                                                  script_data));
+  return base::WrapUnique(
+      new RequestContentScript(master, extension, script_data));
 }
 
 // static
 bool RequestContentScript::InitScriptData(const base::DictionaryValue* dict,
                                           std::string* error,
                                           ScriptData* script_data) {
   const base::ListValue* list_value = NULL;
 
   if (!dict->HasKey(keys::kCss) && !dict->HasKey(keys::kJs)) {
     *error = base::StringPrintf(kMissingParameter, "css or js");
@@ skipping 97 matching lines @@
   content::RenderFrameHost* render_frame_host = contents->GetMainFrame();
   render_frame_host->Send(new ExtensionMsg_ExecuteDeclarativeScript(
       render_frame_host->GetRoutingID(),
       SessionTabHelper::IdForTab(contents),
       extension->id(),
       script_.id(),
       contents->GetLastCommittedURL()));
 }
 
 // static
-scoped_ptr<ContentAction> SetIcon::Create(
+std::unique_ptr<ContentAction> SetIcon::Create(
     content::BrowserContext* browser_context,
     const Extension* extension,
     const base::DictionaryValue* dict,
     std::string* error) {
   // We can't set a page or action's icon if the extension doesn't have one.
   ActionInfo::Type type;
   if (ActionInfo::GetPageActionInfo(extension) != NULL) {
     type = ActionInfo::TYPE_PAGE;
   } else if (ActionInfo::GetBrowserActionInfo(extension) != NULL) {
     type = ActionInfo::TYPE_BROWSER;
   } else {
     *error = kNoPageOrBrowserAction;
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
   }
 
   gfx::ImageSkia icon;
   const base::DictionaryValue* canvas_set = NULL;
   if (dict->GetDictionary("imageData", &canvas_set) &&
       !ExtensionAction::ParseIconFromCanvasDictionary(*canvas_set, &icon)) {
     *error = kInvalidIconDictionary;
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
   }
-  return make_scoped_ptr(new SetIcon(gfx::Image(icon), type));
+  return base::WrapUnique(new SetIcon(gfx::Image(icon), type));
 }
 
 //
 // ContentAction
 //
 
 ContentAction::~ContentAction() {}
 
 // static
-scoped_ptr<ContentAction> ContentAction::Create(
+std::unique_ptr<ContentAction> ContentAction::Create(
     content::BrowserContext* browser_context,
     const Extension* extension,
     const base::Value& json_action,
     std::string* error) {
   error->clear();
   const base::DictionaryValue* action_dict = NULL;
   std::string instance_type;
   if (!(json_action.GetAsDictionary(&action_dict) &&
         action_dict->GetString(keys::kInstanceType, &instance_type)))
-    return scoped_ptr<ContentAction>();
+    return std::unique_ptr<ContentAction>();
 
   ContentActionFactory& factory = g_content_action_factory.Get();
   std::map<std::string, ContentActionFactory::FactoryMethod>::iterator
       factory_method_iter = factory.factory_methods.find(instance_type);
   if (factory_method_iter != factory.factory_methods.end())
     return (*factory_method_iter->second)(
         browser_context, extension, action_dict, error);
 
   *error = base::StringPrintf(kInvalidInstanceTypeError, instance_type.c_str());
-  return scoped_ptr<ContentAction>();
+  return std::unique_ptr<ContentAction>();
 }
 
 ContentAction::ContentAction() {}
 
 }  // namespace extensions