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

extensions/renderer/script_injection_manager.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/script_injection_manager.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/extension_injection_host.h"
@@ skipping 241 matching lines @@
 
 ScriptInjectionManager::~ScriptInjectionManager() {
   for (const auto& injection : pending_injections_)
     injection->invalidate_render_frame();
   for (const auto& injection : running_injections_)
     injection->invalidate_render_frame();
 }
 
 void ScriptInjectionManager::OnRenderFrameCreated(
     content::RenderFrame* render_frame) {
-  rfo_helpers_.push_back(make_scoped_ptr(new RFOHelper(render_frame, this)));
+  rfo_helpers_.push_back(base::WrapUnique(new RFOHelper(render_frame, this)));
 }
 
 void ScriptInjectionManager::OnExtensionUnloaded(
     const std::string& extension_id) {
   for (auto iter = pending_injections_.begin();
       iter != pending_injections_.end();) {
     if ((*iter)->host_id().id() == extension_id) {
       (*iter)->OnHostRemoved();
       iter = pending_injections_.erase(iter);
     } else {
       ++iter;
     }
   }
 }
 
 void ScriptInjectionManager::OnInjectionFinished(
     ScriptInjection* injection) {
   auto iter =
       std::find_if(running_injections_.begin(), running_injections_.end(),
-                   [injection](const scoped_ptr<ScriptInjection>& mode) {
+                   [injection](const std::unique_ptr<ScriptInjection>& mode) {
                      return injection == mode.get();
                    });
   if (iter != running_injections_.end())
     running_injections_.erase(iter);
 }
 
 void ScriptInjectionManager::OnUserScriptsUpdated(
     const std::set<HostID>& changed_hosts,
     const std::vector<UserScript*>& scripts) {
   for (auto iter = pending_injections_.begin();
@@ skipping 87 matching lines @@
 
   // Note that we are running in |frame|.
   active_injection_frames_.insert(frame);
 
   ScriptsRunInfo scripts_run_info(frame, run_location);
   for (auto iter = frame_injections.begin(); iter != frame_injections.end();) {
     // It's possible for the frame to be invalidated in the course of injection
     // (if a script removes its own frame, for example). If this happens, abort.
     if (!active_injection_frames_.count(frame))
       break;
-    scoped_ptr<ScriptInjection> injection(std::move(*iter));
+    std::unique_ptr<ScriptInjection> injection(std::move(*iter));
     iter = frame_injections.erase(iter);
     TryToInject(std::move(injection), run_location, &scripts_run_info);
   }
 
   // We are done running in the frame.
   active_injection_frames_.erase(frame);
 
   scripts_run_info.LogRun();
 }
 
 void ScriptInjectionManager::TryToInject(
-    scoped_ptr<ScriptInjection> injection,
+    std::unique_ptr<ScriptInjection> injection,
     UserScript::RunLocation run_location,
     ScriptsRunInfo* scripts_run_info) {
   // Try to inject the script. If the injection is waiting (i.e., for
   // permission), add it to the list of pending injections. If the injection
   // has blocked, add it to the list of running injections.
   // The Unretained below is safe because this object owns all the
   // ScriptInjections, so is guaranteed to outlive them.
   switch (injection->TryToInject(
       run_location,
       scripts_run_info,
       base::Bind(&ScriptInjectionManager::OnInjectionFinished,
                  base::Unretained(this)))) {
     case ScriptInjection::INJECTION_WAITING:
       pending_injections_.push_back(std::move(injection));
       break;
     case ScriptInjection::INJECTION_BLOCKED:
       running_injections_.push_back(std::move(injection));
       break;
     case ScriptInjection::INJECTION_FINISHED:
       break;
   }
 }
 
 void ScriptInjectionManager::HandleExecuteCode(
     const ExtensionMsg_ExecuteCode_Params& params,
     content::RenderFrame* render_frame) {
-  scoped_ptr<const InjectionHost> injection_host;
+  std::unique_ptr<const InjectionHost> injection_host;
   if (params.host_id.type() == HostID::EXTENSIONS) {
     injection_host = ExtensionInjectionHost::Create(params.host_id.id());
     if (!injection_host)
       return;
   } else if (params.host_id.type() == HostID::WEBUI) {
     injection_host.reset(
         new WebUIInjectionHost(params.host_id));
   }
 
-  scoped_ptr<ScriptInjection> injection(new ScriptInjection(
-      scoped_ptr<ScriptInjector>(
+  std::unique_ptr<ScriptInjection> injection(new ScriptInjection(
+      std::unique_ptr<ScriptInjector>(
           new ProgrammaticScriptInjector(params, render_frame)),
       render_frame, std::move(injection_host),
       static_cast<UserScript::RunLocation>(params.run_at)));
 
   FrameStatusMap::const_iterator iter = frame_statuses_.find(render_frame);
   UserScript::RunLocation run_location =
       iter == frame_statuses_.end() ? UserScript::UNDEFINED : iter->second;
 
   ScriptsRunInfo scripts_run_info(render_frame, run_location);
   TryToInject(std::move(injection), run_location, &scripts_run_info);
 }
 
 void ScriptInjectionManager::HandleExecuteDeclarativeScript(
     content::RenderFrame* render_frame,
     int tab_id,
     const ExtensionId& extension_id,
     int script_id,
     const GURL& url) {
-  scoped_ptr<ScriptInjection> injection =
+  std::unique_ptr<ScriptInjection> injection =
       user_script_set_manager_->GetInjectionForDeclarativeScript(
-          script_id,
-          render_frame,
-          tab_id,
-          url,
-          extension_id);
+          script_id, render_frame, tab_id, url, extension_id);
   if (injection.get()) {
     ScriptsRunInfo scripts_run_info(render_frame, UserScript::BROWSER_DRIVEN);
     // TODO(markdittmer): Use return value of TryToInject for error handling.
     TryToInject(std::move(injection), UserScript::BROWSER_DRIVEN,
                 &scripts_run_info);
 
     scripts_run_info.LogRun();
   }
 }
 
 void ScriptInjectionManager::HandlePermitScriptInjection(int64_t request_id) {
   auto iter = pending_injections_.begin();
   for (; iter != pending_injections_.end(); ++iter) {
     if ((*iter)->request_id() == request_id) {
       DCHECK((*iter)->host_id().type() == HostID::EXTENSIONS);
       break;
     }
   }
   if (iter == pending_injections_.end())
     return;
 
   // At this point, because the request is present in pending_injections_, we
   // know that this is the same page that issued the request (otherwise,
   // RFOHelper::InvalidateAndResetFrame would have caused it to be cleared out).
 
-  scoped_ptr<ScriptInjection> injection(std::move(*iter));
+  std::unique_ptr<ScriptInjection> injection(std::move(*iter));
   pending_injections_.erase(iter);
 
   ScriptsRunInfo scripts_run_info(injection->render_frame(),
                                   UserScript::RUN_DEFERRED);
   ScriptInjection::InjectionResult res = injection->OnPermissionGranted(
       &scripts_run_info);
   if (res == ScriptInjection::INJECTION_BLOCKED)
     running_injections_.push_back(std::move(injection));
   scripts_run_info.LogRun();
 }
 
 }  // namespace extensions