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

content/renderer/pepper/resource_converter.cc

 // Copyright 2013 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 "content/renderer/pepper/resource_converter.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 73 matching lines @@
 }
 
 // Given a V8 value containing a DOMFileSystem, creates a resource host and
 // returns the resource information for serialization.
 // On error, false.
 bool DOMFileSystemToResource(
     PP_Instance instance,
     RendererPpapiHost* host,
     const blink::WebDOMFileSystem& dom_file_system,
     int* pending_renderer_id,
-    scoped_ptr<IPC::Message>* create_message,
-    scoped_ptr<IPC::Message>* browser_host_create_message) {
+    std::unique_ptr<IPC::Message>* create_message,
+    std::unique_ptr<IPC::Message>* browser_host_create_message) {
   DCHECK(!dom_file_system.isNull());
 
   PP_FileSystemType file_system_type =
       WebFileSystemTypeToPPAPI(dom_file_system.type());
   GURL root_url = dom_file_system.rootURL();
 
   // Raw external file system access is not allowed, but external file system
   // access through fileapi is allowed. (Without this check, there would be a
   // CHECK failure in FileRefResource.)
   if ((file_system_type == PP_FILESYSTEMTYPE_EXTERNAL) &&
       (!root_url.is_valid())) {
     return false;
   }
 
   *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
-      scoped_ptr<ppapi::host::ResourceHost>(new PepperFileSystemHost(
+      std::unique_ptr<ppapi::host::ResourceHost>(new PepperFileSystemHost(
           host, instance, 0, root_url, file_system_type)));
   if (*pending_renderer_id == 0)
     return false;
 
   create_message->reset(
       new PpapiPluginMsg_FileSystem_CreateFromPendingHost(file_system_type));
 
   browser_host_create_message->reset(
       new PpapiHostMsg_FileSystem_CreateFromRenderer(root_url.spec(),
                                                      file_system_type));
@@ skipping 34 matching lines @@
   // blink::WebMediaStreamTrack track = host->track();
   // *dom_video_track = track.toV8Value();
   return false;
 }
 
 bool DOMMediaStreamTrackToResource(
     PP_Instance instance,
     RendererPpapiHost* host,
     const blink::WebDOMMediaStreamTrack& dom_media_stream_track,
     int* pending_renderer_id,
-    scoped_ptr<IPC::Message>* create_message) {
+    std::unique_ptr<IPC::Message>* create_message) {
   DCHECK(!dom_media_stream_track.isNull());
   *pending_renderer_id = 0;
 #if defined(ENABLE_WEBRTC)
   const blink::WebMediaStreamTrack track = dom_media_stream_track.component();
   const std::string id = track.source().id().utf8();
 
   if (track.source().getType() == blink::WebMediaStreamSource::TypeVideo) {
     *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
-        scoped_ptr<ppapi::host::ResourceHost>(
+        std::unique_ptr<ppapi::host::ResourceHost>(
             new PepperMediaStreamVideoTrackHost(host, instance, 0, track)));
     if (*pending_renderer_id == 0)
       return false;
 
     create_message->reset(
         new PpapiPluginMsg_MediaStreamVideoTrack_CreateFromPendingHost(id));
     return true;
   } else if (track.source().getType() ==
              blink::WebMediaStreamSource::TypeAudio) {
     *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
-        scoped_ptr<ppapi::host::ResourceHost>(
+        std::unique_ptr<ppapi::host::ResourceHost>(
             new PepperMediaStreamAudioTrackHost(host, instance, 0, track)));
     if (*pending_renderer_id == 0)
       return false;
 
     create_message->reset(
         new PpapiPluginMsg_MediaStreamAudioTrack_CreateFromPendingHost(id));
     return true;
   }
 #endif
   return false;
@@ skipping 19 matching lines @@
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
   RendererPpapiHost* host = RendererPpapiHost::GetForPPInstance(instance_);
 
   *was_resource = false;
 
   blink::WebDOMFileSystem dom_file_system =
       blink::WebDOMFileSystem::fromV8Value(val);
   if (!dom_file_system.isNull()) {
     int pending_renderer_id;
-    scoped_ptr<IPC::Message> create_message;
-    scoped_ptr<IPC::Message> browser_host_create_message;
+    std::unique_ptr<IPC::Message> create_message;
+    std::unique_ptr<IPC::Message> browser_host_create_message;
     if (!DOMFileSystemToResource(instance_,
                                  host,
                                  dom_file_system,
                                  &pending_renderer_id,
                                  &create_message,
                                  &browser_host_create_message)) {
       return false;
     }
     DCHECK(create_message);
     DCHECK(browser_host_create_message);
     scoped_refptr<HostResourceVar> result_var =
         CreateResourceVarWithBrowserHost(
             pending_renderer_id, *create_message, *browser_host_create_message);
     *result = result_var->GetPPVar();
     *was_resource = true;
     return true;
   }
 
   blink::WebDOMMediaStreamTrack dom_media_stream_track =
       blink::WebDOMMediaStreamTrack::fromV8Value(val);
   if (!dom_media_stream_track.isNull()) {
     int pending_renderer_id;
-    scoped_ptr<IPC::Message> create_message;
+    std::unique_ptr<IPC::Message> create_message;
     if (!DOMMediaStreamTrackToResource(instance_,
                                        host,
                                        dom_media_stream_track,
                                        &pending_renderer_id,
                                        &create_message)) {
       return false;
     }
     DCHECK(create_message);
     scoped_refptr<HostResourceVar> result_var =
         CreateResourceVar(pending_renderer_id, *create_message);
@@ skipping 86 matching lines @@
     const IPC::Message& create_message,
     const IPC::Message& browser_host_create_message) {
   scoped_refptr<HostResourceVar> result =
       CreateResourceVar(pending_renderer_id, create_message);
   browser_host_create_messages_.push_back(browser_host_create_message);
   browser_vars_.push_back(result);
   return result;
 }
 
 }  // namespace content