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

extensions/renderer/script_injection.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.h"
 
 #include <map>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 97 matching lines @@
       return iter.first;
   }
   return std::string();
 }
 
 // static
 void ScriptInjection::RemoveIsolatedWorld(const std::string& host_id) {
   g_isolated_worlds.Get().erase(host_id);
 }
 
-ScriptInjection::ScriptInjection(scoped_ptr<ScriptInjector> injector,
-                                 content::RenderFrame* render_frame,
-                                 scoped_ptr<const InjectionHost> injection_host,
-                                 UserScript::RunLocation run_location)
+ScriptInjection::ScriptInjection(
+    std::unique_ptr<ScriptInjector> injector,
+    content::RenderFrame* render_frame,
+    std::unique_ptr<const InjectionHost> injection_host,
+    UserScript::RunLocation run_location)
     : injector_(std::move(injector)),
       render_frame_(render_frame),
       injection_host_(std::move(injection_host)),
       run_location_(run_location),
       request_id_(kInvalidRequestId),
       complete_(false),
       did_inject_js_(false),
       frame_watcher_(new FrameWatcher(render_frame, this)),
       weak_ptr_factory_(this) {
   CHECK(injection_host_.get());
@@ skipping 107 matching lines @@
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   std::vector<blink::WebScriptSource> sources =
       injector_->GetJsSources(run_location_);
   bool in_main_world = injector_->ShouldExecuteInMainWorld();
   int world_id = in_main_world
                      ? DOMActivityLogger::kMainWorldId
                      : GetIsolatedWorldIdForInstance(injection_host_.get(),
                                                      web_frame);
   bool is_user_gesture = injector_->IsUserGesture();
 
-  scoped_ptr<blink::WebScriptExecutionCallback> callback(
+  std::unique_ptr<blink::WebScriptExecutionCallback> callback(
       new ScriptInjectionCallback(
           base::Bind(&ScriptInjection::OnJsInjectionCompleted,
                      weak_ptr_factory_.GetWeakPtr())));
 
   base::ElapsedTimer exec_timer;
   if (injection_host_->id().type() == HostID::EXTENSIONS)
     DOMActivityLogger::AttachToWorld(world_id, injection_host_->id().id());
   if (in_main_world) {
     // We only inject in the main world for javascript: urls.
     DCHECK_EQ(1u, sources.size());
@@ skipping 16 matching lines @@
 }
 
 void ScriptInjection::OnJsInjectionCompleted(
     const blink::WebVector<v8::Local<v8::Value> >& results) {
   DCHECK(!did_inject_js_);
 
   bool expects_results = injector_->ExpectsResults();
   if (expects_results) {
     if (!results.isEmpty() && !results[0].IsEmpty()) {
       // Right now, we only support returning single results (per frame).
-      scoped_ptr<content::V8ValueConverter> v8_converter(
+      std::unique_ptr<content::V8ValueConverter> v8_converter(
           content::V8ValueConverter::create());
       // It's safe to always use the main world context when converting
       // here. V8ValueConverterImpl shouldn't actually care about the
       // context scope, and it switches to v8::Object's creation context
       // when encountered.
       v8::Local<v8::Context> context =
           render_frame_->GetWebFrame()->mainWorldScriptContext();
       execution_result_.reset(v8_converter->FromV8Value(results[0], context));
     }
     if (!execution_result_.get())
@@ skipping 13 matching lines @@
 
 void ScriptInjection::InjectCss() {
   std::vector<std::string> css_sources =
       injector_->GetCssSources(run_location_);
   blink::WebLocalFrame* web_frame = render_frame_->GetWebFrame();
   for (const std::string& css : css_sources)
     web_frame->document().insertStyleSheet(blink::WebString::fromUTF8(css));
 }
 
 }  // namespace extensions