Convert //extensions/renderer from scoped_ptr to std::unique_ptr

extensions/renderer/user_script_set.cc

 // Copyright 2014 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 "extensions/renderer/user_script_set.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 49 matching lines @@
     std::set<std::string>* ids) const {
   for (const UserScript* script : scripts_) {
     if (script->host_id().type() != HostID::EXTENSIONS)
       continue;
     DCHECK(!script->extension_id().empty());
     ids->insert(script->extension_id());
   }
 }
 
 void UserScriptSet::GetInjections(
-    std::vector<scoped_ptr<ScriptInjection>>* injections,
+    std::vector<std::unique_ptr<ScriptInjection>>* injections,
     content::RenderFrame* render_frame,
     int tab_id,
     UserScript::RunLocation run_location) {
   GURL document_url = GetDocumentUrlForFrame(render_frame->GetWebFrame());
   for (const UserScript* script : scripts_) {
-    scoped_ptr<ScriptInjection> injection = GetInjectionForScript(
-        script,
-        render_frame,
-        tab_id,
-        run_location,
-        document_url,
-        false /* is_declarative */);
+    std::unique_ptr<ScriptInjection> injection =
+        GetInjectionForScript(script, render_frame, tab_id, run_location,
+                              document_url, false /* is_declarative */);
     if (injection.get())
       injections->push_back(std::move(injection));
   }
 }
 
 bool UserScriptSet::UpdateUserScripts(base::SharedMemoryHandle shared_memory,
                                       const std::set<HostID>& changed_hosts,
                                       bool whitelisted_only) {
   bool only_inject_incognito =
       ExtensionsRendererClient::Get()->IsIncognitoProcess();
@@ skipping 18 matching lines @@
   // Unpickle scripts.
   uint32_t num_scripts = 0;
   base::Pickle pickle(reinterpret_cast<char*>(shared_memory_->memory()),
                       pickle_size);
   base::PickleIterator iter(pickle);
   CHECK(iter.ReadUInt32(&num_scripts));
 
   scripts_.clear();
   scripts_.reserve(num_scripts);
   for (uint32_t i = 0; i < num_scripts; ++i) {
-    scoped_ptr<UserScript> script(new UserScript());
+    std::unique_ptr<UserScript> script(new UserScript());
     script->Unpickle(pickle, &iter);
 
     // Note that this is a pointer into shared memory. We don't own it. It gets
     // cleared up when the last renderer or browser process drops their
     // reference to the shared memory.
     for (size_t j = 0; j < script->js_scripts().size(); ++j) {
       const char* body = NULL;
       int body_length = 0;
       CHECK(iter.ReadData(&body, &body_length));
       script->js_scripts()[j].set_external_content(
@@ skipping 20 matching lines @@
 
     scripts_.push_back(std::move(script));
   }
 
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnUserScriptsUpdated(changed_hosts, scripts_.get()));
   return true;
 }
 
-scoped_ptr<ScriptInjection> UserScriptSet::GetDeclarativeScriptInjection(
+std::unique_ptr<ScriptInjection> UserScriptSet::GetDeclarativeScriptInjection(
     int script_id,
     content::RenderFrame* render_frame,
     int tab_id,
     UserScript::RunLocation run_location,
     const GURL& document_url) {
   for (const UserScript* script : scripts_) {
     if (script->id() == script_id) {
       return GetInjectionForScript(script,
                                    render_frame,
                                    tab_id,
                                    run_location,
                                    document_url,
                                    true /* is_declarative */);
     }
   }
-  return scoped_ptr<ScriptInjection>();
+  return std::unique_ptr<ScriptInjection>();
 }
 
-scoped_ptr<ScriptInjection> UserScriptSet::GetInjectionForScript(
+std::unique_ptr<ScriptInjection> UserScriptSet::GetInjectionForScript(
     const UserScript* script,
     content::RenderFrame* render_frame,
     int tab_id,
     UserScript::RunLocation run_location,
     const GURL& document_url,
     bool is_declarative) {
-  scoped_ptr<ScriptInjection> injection;
-  scoped_ptr<const InjectionHost> injection_host;
+  std::unique_ptr<ScriptInjection> injection;
+  std::unique_ptr<const InjectionHost> injection_host;
   blink::WebLocalFrame* web_frame = render_frame->GetWebFrame();
 
   const HostID& host_id = script->host_id();
   if (host_id.type() == HostID::EXTENSIONS) {
     injection_host = ExtensionInjectionHost::Create(host_id.id());
     if (!injection_host)
       return injection;
   } else {
     DCHECK_EQ(host_id.type(), HostID::WEBUI);
     injection_host.reset(new WebUIInjectionHost(host_id));
   }
 
   if (web_frame->parent() && !script->match_all_frames())
     return injection;  // Only match subframes if the script declared it.
 
   GURL effective_document_url = ScriptContext::GetEffectiveDocumentURL(
       web_frame, document_url, script->match_about_blank());
 
   if (!script->MatchesURL(effective_document_url))
     return injection;
 
-  scoped_ptr<ScriptInjector> injector(new UserScriptInjector(script,
-                                                             this,
-                                                             is_declarative));
+  std::unique_ptr<ScriptInjector> injector(
+      new UserScriptInjector(script, this, is_declarative));
 
   if (injector->CanExecuteOnFrame(
           injection_host.get(),
           web_frame,
           tab_id) ==
       PermissionsData::ACCESS_DENIED) {
     return injection;
   }
 
   bool inject_css = !script->css_scripts().empty() &&
                     run_location == UserScript::DOCUMENT_START;
   bool inject_js =
       !script->js_scripts().empty() && script->run_location() == run_location;
   if (inject_css || inject_js) {
     injection.reset(new ScriptInjection(std::move(injector), render_frame,
                                         std::move(injection_host),
                                         run_location));
   }
   return injection;
 }
 
 }  // namespace extensions