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

extensions/renderer/display_source_custom_bindings.cc

 // Copyright 2015 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/display_source_custom_bindings.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "content/public/child/v8_value_converter.h"
@@ skipping 111 matching lines @@
     audio_track =
         blink::WebDOMMediaStreamTrack::fromV8Value(
             audio_stream_val).component();
     if (audio_track.isNull()) {
       isolate->ThrowException(v8::Exception::Error(
           v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
       return;
     }
   }
 
-  scoped_ptr<DisplaySourceAuthInfo> auth_info;
+  std::unique_ptr<DisplaySourceAuthInfo> auth_info;
   v8::Local<v8::Value> auth_info_v8_val =
       GetChildValue(start_info, "authenticationInfo", isolate);
   if (!auth_info_v8_val->IsNull()) {
     CHECK(auth_info_v8_val->IsObject());
-    scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-    scoped_ptr<base::Value> auth_info_val(
+    std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+    std::unique_ptr<base::Value> auth_info_val(
         converter->FromV8Value(auth_info_v8_val, context()->v8_context()));
     CHECK(auth_info_val);
     auth_info = DisplaySourceAuthInfo::FromValue(*auth_info_val);
   }
 
   DisplaySourceSessionParams session_params;
   session_params.sink_id = sink_id;
   session_params.video_track = video_track;
   session_params.audio_track = audio_track;
   session_params.render_frame = context()->GetRenderFrame();
   if (auth_info) {
     session_params.auth_method = auth_info->method;
     session_params.auth_data = auth_info->data ? *auth_info->data : "";
   }
-  scoped_ptr<DisplaySourceSession> session =
+  std::unique_ptr<DisplaySourceSession> session =
       DisplaySourceSessionFactory::CreateSession(session_params);
   if (!session) {
     isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
         isolate, kErrorNotSupported)));
     return;
   }
 
   auto on_terminated_callback =
       base::Bind(&DisplaySourceCustomBindings::OnSessionTerminated,
                  weak_factory_.GetWeakPtr(), sink_id);
@@ skipping 100 matching lines @@
     const std::string& message) const {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
   api::display_source::ErrorInfo error_info;
   error_info.type = type;
   if (!message.empty())
     error_info.description.reset(new std::string(message));
 
-  scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   v8::Local<v8::Value> info_arg =
       converter->ToV8Value(error_info.ToValue().get(),
                            context()->v8_context());
 
   v8::Local<v8::Array> event_args = v8::Array::New(isolate, 2);
   event_args->Set(0, v8::Integer::New(isolate, sink_id));
   event_args->Set(1, info_arg);
   context()->DispatchEvent("displaySource.onSessionErrorOccured", event_args);
 }
 
@@ skipping 12 matching lines @@
 }
 
 void DisplaySourceCustomBindings::OnSessionError(int sink_id,
                                                  DisplaySourceErrorType type,
                                                  const std::string& message) {
   CHECK(GetDisplaySession(sink_id));
   DispatchSessionError(sink_id, type, message);
 }
 
 }  // extensions