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

content/browser/android/in_process/synchronous_compositor_factory_impl.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 "content/browser/android/in_process/synchronous_compositor_factory_impl.h"
 
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/android/in_process/context_provider_in_process.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
 #include "content/browser/android/in_process/synchronous_compositor_registry_in_proc.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 13 matching lines @@
 
 using cc_blink::ContextProviderWebContext;
 using gpu_blink::WebGraphicsContext3DImpl;
 using gpu_blink::WebGraphicsContext3DInProcessCommandBufferImpl;
 
 namespace content {
 
 namespace {
 
 struct ContextHolder {
-  scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> command_buffer;
+  std::unique_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
+      command_buffer;
   gpu::GLInProcessContext* gl_in_process_context;
 };
 
 ContextHolder CreateContextHolder(
     const gpu::gles2::ContextCreationAttribHelper& attributes,
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     const gpu::GLInProcessContextSharedMemoryLimits& mem_limits) {
   bool is_offscreen = true;
-  scoped_ptr<gpu::GLInProcessContext> context(gpu::GLInProcessContext::Create(
-      service, nullptr /* surface */, is_offscreen, gfx::kNullAcceleratedWidget,
-      gfx::Size(1, 1), nullptr /* share_context */, attributes,
-      gfx::PreferDiscreteGpu, mem_limits,
-      BrowserGpuMemoryBufferManager::current(), nullptr));
+  std::unique_ptr<gpu::GLInProcessContext> context(
+      gpu::GLInProcessContext::Create(
+          service, nullptr /* surface */, is_offscreen,
+          gfx::kNullAcceleratedWidget, gfx::Size(1, 1),
+          nullptr /* share_context */, attributes, gfx::PreferDiscreteGpu,
+          mem_limits, BrowserGpuMemoryBufferManager::current(), nullptr));
 
   gpu::GLInProcessContext* context_ptr = context.get();
 
   ContextHolder holder;
   holder.command_buffer =
-      scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>(
+      std::unique_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>(
           WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
               std::move(context), attributes));
   holder.gl_in_process_context = context_ptr;
 
   return holder;
 }
 
 }  // namespace
 
 SynchronousCompositorFactoryImpl::SynchronousCompositorFactoryImpl() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSingleProcess)) {
     // TODO(boliu): Figure out how to deal with this more nicely.
     SynchronousCompositorFactory::SetInstance(this);
   }
 }
 
 SynchronousCompositorFactoryImpl::~SynchronousCompositorFactoryImpl() {}
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SynchronousCompositorFactoryImpl::GetCompositorTaskRunner() {
   return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
 }
 
-scoped_ptr<cc::OutputSurface>
+std::unique_ptr<cc::OutputSurface>
 SynchronousCompositorFactoryImpl::CreateOutputSurface(
     int routing_id,
     uint32_t output_surface_id,
     const scoped_refptr<FrameSwapMessageQueue>& frame_swap_message_queue,
     const scoped_refptr<cc::ContextProvider>& onscreen_context,
     const scoped_refptr<cc::ContextProvider>& worker_context) {
-  return make_scoped_ptr(new SynchronousCompositorOutputSurface(
+  return base::WrapUnique(new SynchronousCompositorOutputSurface(
       onscreen_context, worker_context, routing_id, output_surface_id,
       SynchronousCompositorRegistryInProc::GetInstance(),
       frame_swap_message_queue));
 }
 
 InputHandlerManagerClient*
 SynchronousCompositorFactoryImpl::GetInputHandlerManagerClient() {
   return synchronous_input_event_filter();
 }
 
 SynchronousInputHandlerProxyClient*
 SynchronousCompositorFactoryImpl::GetSynchronousInputHandlerProxyClient() {
   return synchronous_input_event_filter();
 }
 
-scoped_ptr<cc::BeginFrameSource>
+std::unique_ptr<cc::BeginFrameSource>
 SynchronousCompositorFactoryImpl::CreateExternalBeginFrameSource(
     int routing_id) {
-  return make_scoped_ptr(new SynchronousCompositorExternalBeginFrameSource(
+  return base::WrapUnique(new SynchronousCompositorExternalBeginFrameSource(
       routing_id, SynchronousCompositorRegistryInProc::GetInstance()));
 }
 
 // SynchronousCompositorStreamTextureFactoryImpl.
 
 class SynchronousCompositorStreamTextureFactoryImpl::VideoContextProvider
     : public StreamTextureFactorySynchronousImpl::ContextProvider {
  public:
   VideoContextProvider(scoped_refptr<cc::ContextProvider> context_provider,
                        gpu::GLInProcessContext* gl_in_process_context)
@@ skipping 141 matching lines @@
   DCHECK(!android_view_service_.get());
   android_view_service_ = service;
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSingleProcess)) {
     RenderThreadImpl::SetStreamTextureFactory(CreateStreamTextureFactory());
   }
 }
 
 }  // namespace content