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

content/renderer/render_thread_impl.h

Index: content/renderer/render_thread_impl.h
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 3d1b5bfc737d4cc574e343a76ea8884e8abfa5f5..28379f06c69b2b9cf49611b3b42e6a449ef8b705 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -154,8 +154,8 @@ class CONTENT_EXPORT RenderThreadImpl
  public:
   static RenderThreadImpl* Create(const InProcessChildThreadParams& params);
   static RenderThreadImpl* Create(
-      scoped_ptr<base::MessageLoop> main_message_loop,
-      scoped_ptr<scheduler::RendererScheduler> renderer_scheduler);
+      std::unique_ptr<base::MessageLoop> main_message_loop,
+      std::unique_ptr<scheduler::RendererScheduler> renderer_scheduler);
   static RenderThreadImpl* current();
 
   ~RenderThreadImpl() override;
@@ -184,7 +184,7 @@ class CONTENT_EXPORT RenderThreadImpl
   void RemoveObserver(RenderProcessObserver* observer) override;
   void SetResourceDispatcherDelegate(
       ResourceDispatcherDelegate* delegate) override;
-  scoped_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
+  std::unique_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
       size_t buffer_size) override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
   void RegisterExtension(v8::Extension* extension) override;
@@ -217,7 +217,7 @@ class CONTENT_EXPORT RenderThreadImpl
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
   scheduler::RendererScheduler* GetRendererScheduler() override;
   cc::ContextProvider* GetSharedMainThreadContextProvider() override;
-  scoped_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
+  std::unique_ptr<cc::BeginFrameSource> CreateExternalBeginFrameSource(
       int routing_id) override;
   cc::ImageSerializationProcessor* GetImageSerializationProcessor() override;
   cc::TaskGraphRunner* GetTaskGraphRunner() override;
@@ -462,10 +462,10 @@ class CONTENT_EXPORT RenderThreadImpl
  protected:
   RenderThreadImpl(
       const InProcessChildThreadParams& params,
-      scoped_ptr<scheduler::RendererScheduler> scheduler,
+      std::unique_ptr<scheduler::RendererScheduler> scheduler,
       scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
-  RenderThreadImpl(scoped_ptr<base::MessageLoop> main_message_loop,
-                   scoped_ptr<scheduler::RendererScheduler> scheduler);
+  RenderThreadImpl(std::unique_ptr<base::MessageLoop> main_message_loop,
+                   std::unique_ptr<scheduler::RendererScheduler> scheduler);
 
  private:
   // ChildThread
@@ -477,7 +477,8 @@ class CONTENT_EXPORT RenderThreadImpl
   // GpuChannelHostFactory implementation:
   bool IsMainThread() override;
   scoped_refptr<base::SingleThreadTaskRunner> GetIOThreadTaskRunner() override;
-  scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) override;
+  std::unique_ptr<base::SharedMemory> AllocateSharedMemory(
+      size_t size) override;
 
   void Init(scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
 
@@ -525,17 +526,18 @@ class CONTENT_EXPORT RenderThreadImpl
 
   void ReleaseFreeMemory();
 
-  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateOffscreenContext3d();
+  std::unique_ptr<WebGraphicsContext3DCommandBufferImpl>
+  CreateOffscreenContext3d();
 
   // These objects live solely on the render thread.
-  scoped_ptr<AppCacheDispatcher> appcache_dispatcher_;
-  scoped_ptr<DomStorageDispatcher> dom_storage_dispatcher_;
-  scoped_ptr<IndexedDBDispatcher> main_thread_indexed_db_dispatcher_;
-  scoped_ptr<scheduler::RendererScheduler> renderer_scheduler_;
-  scoped_ptr<RendererBlinkPlatformImpl> blink_platform_impl_;
-  scoped_ptr<ResourceDispatchThrottler> resource_dispatch_throttler_;
-  scoped_ptr<CacheStorageDispatcher> main_thread_cache_storage_dispatcher_;
-  scoped_ptr<EmbeddedWorkerDispatcher> embedded_worker_dispatcher_;
+  std::unique_ptr<AppCacheDispatcher> appcache_dispatcher_;
+  std::unique_ptr<DomStorageDispatcher> dom_storage_dispatcher_;
+  std::unique_ptr<IndexedDBDispatcher> main_thread_indexed_db_dispatcher_;
+  std::unique_ptr<scheduler::RendererScheduler> renderer_scheduler_;
+  std::unique_ptr<RendererBlinkPlatformImpl> blink_platform_impl_;
+  std::unique_ptr<ResourceDispatchThrottler> resource_dispatch_throttler_;
+  std::unique_ptr<CacheStorageDispatcher> main_thread_cache_storage_dispatcher_;
+  std::unique_ptr<EmbeddedWorkerDispatcher> embedded_worker_dispatcher_;
 
   // Used on the render thread and deleted by WebKit at shutdown.
   blink::WebMediaStreamCenter* media_stream_center_;
@@ -550,23 +552,23 @@ class CONTENT_EXPORT RenderThreadImpl
   scoped_refptr<RendererDemuxerAndroid> renderer_demuxer_;
 #endif
   scoped_refptr<DevToolsAgentFilter> devtools_agent_message_filter_;
-  scoped_ptr<V8SamplingProfiler> v8_sampling_profiler_;
+  std::unique_ptr<V8SamplingProfiler> v8_sampling_profiler_;
 
-  scoped_ptr<BrowserPluginManager> browser_plugin_manager_;
+  std::unique_ptr<BrowserPluginManager> browser_plugin_manager_;
 
 #if defined(ENABLE_WEBRTC)
-  scoped_ptr<PeerConnectionDependencyFactory> peer_connection_factory_;
+  std::unique_ptr<PeerConnectionDependencyFactory> peer_connection_factory_;
 
   // This is used to communicate to the browser process the status
   // of all the peer connections created in the renderer.
-  scoped_ptr<PeerConnectionTracker> peer_connection_tracker_;
+  std::unique_ptr<PeerConnectionTracker> peer_connection_tracker_;
 
   // Dispatches all P2P sockets.
   scoped_refptr<P2PSocketDispatcher> p2p_socket_dispatcher_;
 #endif
 
   // Used on the render thread.
-  scoped_ptr<VideoCaptureImplManager> vc_manager_;
+  std::unique_ptr<VideoCaptureImplManager> vc_manager_;
 
   // Used for communicating registering AEC dump consumers with the browser and
   // receving AEC dump file handles when AEC dump is enabled. An AEC dump is
@@ -605,13 +607,13 @@ class CONTENT_EXPORT RenderThreadImpl
   // The message loop of the renderer main thread.
   // This message loop should be destructed before the RenderThreadImpl
   // shuts down Blink.
-  scoped_ptr<base::MessageLoop> main_message_loop_;
+  std::unique_ptr<base::MessageLoop> main_message_loop_;
 
   // A lazily initiated thread on which file operations are run.
-  scoped_ptr<base::Thread> file_thread_;
+  std::unique_ptr<base::Thread> file_thread_;
 
   // May be null if overridden by ContentRendererClient.
-  scoped_ptr<scheduler::WebThreadBase> compositor_thread_;
+  std::unique_ptr<scheduler::WebThreadBase> compositor_thread_;
 
   // Utility class to provide GPU functionalities to media.
   // TODO(dcastagna): This should be just one scoped_ptr once
@@ -620,7 +622,7 @@ class CONTENT_EXPORT RenderThreadImpl
   ScopedVector<content::RendererGpuVideoAcceleratorFactories> gpu_factories_;
 
   // Thread for running multimedia operations (e.g., video decoding).
-  scoped_ptr<base::Thread> media_thread_;
+  std::unique_ptr<base::Thread> media_thread_;
 
   // Will point to appropriate task runner after initialization,
   // regardless of whether |compositor_thread_| is overriden.
@@ -631,7 +633,7 @@ class CONTENT_EXPORT RenderThreadImpl
 
   base::CancelableCallback<void(const IPC::Message&)> main_input_callback_;
   scoped_refptr<IPC::MessageFilter> input_event_filter_;
-  scoped_ptr<InputHandlerManager> input_handler_manager_;
+  std::unique_ptr<InputHandlerManager> input_handler_manager_;
   scoped_refptr<CompositorForwardingMessageFilter> compositor_message_filter_;
 
 #if defined(OS_ANDROID)
@@ -647,18 +649,18 @@ class CONTENT_EXPORT RenderThreadImpl
 
   scoped_refptr<ContextProviderCommandBuffer> shared_worker_context_provider_;
 
-  scoped_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_;
-  scoped_ptr<media::AudioHardwareConfig> audio_hardware_config_;
+  std::unique_ptr<AudioRendererMixerManager> audio_renderer_mixer_manager_;
+  std::unique_ptr<media::AudioHardwareConfig> audio_hardware_config_;
 
   HistogramCustomizer histogram_customizer_;
 
-  scoped_ptr<base::MemoryPressureListener> memory_pressure_listener_;
+  std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
 #if defined(ENABLE_WEBRTC)
-  scoped_ptr<WebRTCIdentityService> webrtc_identity_service_;
+  std::unique_ptr<WebRTCIdentityService> webrtc_identity_service_;
 #endif
 
-  scoped_ptr<MemoryObserver> memory_observer_;
+  std::unique_ptr<MemoryObserver> memory_observer_;
 
   scoped_refptr<base::SingleThreadTaskRunner>
       main_thread_compositor_task_runner_;