Add switch to use ipc command buffer in Android WebView

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 "base/command_line.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_external_begin_frame_source.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
 #include "content/browser/android/in_process/synchronous_compositor_output_surface.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/gpu_channel_host.h"
+#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/gpu/in_process_gpu_thread.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
+#include "content/renderer/render_thread_impl.h"
 #include "gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_surface_stub.h"
 
 using cc_blink::ContextProviderWebContext;
 using gpu_blink::WebGraphicsContext3DImpl;
@@ skipping 39 matching lines @@
   ContextHolder holder;
   holder.command_buffer =
       scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>(
           WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
               context.Pass(), attributes));
   holder.gl_in_process_context = context_ptr;
 
   return holder;
 }
 
+scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContext3D(
+    const blink::WebGraphicsContext3D::Attributes& attributes,
+    const content::WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits&
+        mem_limits) {
+  DCHECK(RenderThreadImpl::current());
+  CauseForGpuLaunch cause =
+      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+  scoped_refptr<GpuChannelHost> gpu_channel_host(
+      RenderThreadImpl::current()->EstablishGpuChannelSync(cause));
+  CHECK(gpu_channel_host.get());
+
+  int surface_id = 0;
+  bool lose_context_when_out_of_memory = true;
+  return make_scoped_ptr(new WebGraphicsContext3DCommandBufferImpl(
+      surface_id, GURL(), gpu_channel_host.get(), attributes,
+      lose_context_when_out_of_memory, mem_limits, NULL));
+}
+
 }  // namespace
 
 class SynchronousCompositorFactoryImpl::VideoContextProvider
     : public StreamTextureFactorySynchronousImpl::ContextProvider {
  public:
   VideoContextProvider(
       scoped_refptr<cc::ContextProvider> context_provider,
       gpu::GLInProcessContext* gl_in_process_context)
       : context_provider_(context_provider),
         gl_in_process_context_(gl_in_process_context) {
@@ skipping 27 matching lines @@
   friend class base::RefCountedThreadSafe<VideoContextProvider>;
   ~VideoContextProvider() override {}
 
   scoped_refptr<cc::ContextProvider> context_provider_;
   gpu::GLInProcessContext* gl_in_process_context_;
   base::ObserverList<StreamTextureFactoryContextObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoContextProvider);
 };
 
-
 SynchronousCompositorFactoryImpl::SynchronousCompositorFactoryImpl()
     : record_full_layer_(true),
+      use_ipc_command_buffer_(false),
       num_hardware_compositors_(0) {
   SynchronousCompositorFactory::SetInstance(this);
 }
 
 SynchronousCompositorFactoryImpl::~SynchronousCompositorFactoryImpl() {}
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SynchronousCompositorFactoryImpl::GetCompositorTaskRunner() {
   return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
 }
 
 bool
 SynchronousCompositorFactoryImpl::RecordFullLayer() {
   return record_full_layer_;
 }
 
 scoped_ptr<cc::OutputSurface>
 SynchronousCompositorFactoryImpl::CreateOutputSurface(
     int routing_id,
     scoped_refptr<content::FrameSwapMessageQueue> frame_swap_message_queue) {
   scoped_refptr<cc::ContextProvider> onscreen_context =
-      CreateContextProviderForCompositor();
+      CreateContextProviderForCompositor(RENDER_COMPOSITOR_CONTEXT);
   scoped_refptr<cc::ContextProvider> worker_context =
-      CreateContextProviderForCompositor();
+      CreateContextProviderForCompositor(RENDER_WORKER_CONTEXT);
 
   return make_scoped_ptr(new SynchronousCompositorOutputSurface(
       onscreen_context, worker_context, routing_id, frame_swap_message_queue));
 }
 
 InputHandlerManagerClient*
 SynchronousCompositorFactoryImpl::GetInputHandlerManagerClient() {
   return synchronous_input_event_filter();
 }
 
 scoped_ptr<cc::BeginFrameSource>
 SynchronousCompositorFactoryImpl::CreateExternalBeginFrameSource(
     int routing_id) {
   return make_scoped_ptr(
              new SynchronousCompositorExternalBeginFrameSource(routing_id));
 }
 
+bool SynchronousCompositorFactoryImpl::OverrideWithFactory() {
+  return !use_ipc_command_buffer_;
+}
+
 scoped_refptr<ContextProviderWebContext>
 SynchronousCompositorFactoryImpl::CreateOffscreenContextProvider(
     const blink::WebGraphicsContext3D::Attributes& attributes,
     const std::string& debug_name) {
+  DCHECK(!use_ipc_command_buffer_);
   ContextHolder holder =
       CreateContextHolder(attributes, GpuThreadService(),
                           gpu::GLInProcessContextSharedMemoryLimits(), true);
   return ContextProviderInProcess::Create(holder.command_buffer.Pass(),
                                           debug_name);
 }
 
 scoped_refptr<cc::ContextProvider>
-SynchronousCompositorFactoryImpl::CreateContextProviderForCompositor() {
+SynchronousCompositorFactoryImpl::CreateContextProviderForCompositor(
+    CommandBufferContextType type) {
+  // This is half of what RenderWidget uses because synchronous compositor
+  // pipeline is only one frame deep. But twice of half for low end here
+  // because 16bit texture is not supported.
+  unsigned int mapped_memory_reclaim_limit =
+      (base::SysInfo::IsLowEndDevice() ? 2 : 6) * 1024 * 1024;
   blink::WebGraphicsContext3D::Attributes attributes = GetDefaultAttribs();
+
+  if (use_ipc_command_buffer_) {
+    WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits mem_limits;
+    mem_limits.mapped_memory_reclaim_limit = mapped_memory_reclaim_limit;
+    scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context =
+        CreateContext3D(GetDefaultAttribs(), mem_limits);
+    return ContextProviderCommandBuffer::Create(context.Pass(), type);
+  }
+
   gpu::GLInProcessContextSharedMemoryLimits mem_limits;
-  // This is half of what RenderWidget uses because synchronous compositor
-  // pipeline is only one frame deep.
-  if (base::SysInfo::IsLowEndDevice()) {
-    // But twice of half here because 16bit texture is not supported.
-    mem_limits.mapped_memory_reclaim_limit = 2 * 1024 * 1024;
-  } else {
-    mem_limits.mapped_memory_reclaim_limit = 6 * 1024 * 1024;
-  }
+  mem_limits.mapped_memory_reclaim_limit = mapped_memory_reclaim_limit;
   ContextHolder holder =
       CreateContextHolder(attributes, GpuThreadService(), mem_limits, true);
   return ContextProviderInProcess::Create(holder.command_buffer.Pass(),
                                           "Child-Compositor");
 }
 
 scoped_refptr<StreamTextureFactory>
 SynchronousCompositorFactoryImpl::CreateStreamTextureFactory(int frame_id) {
   scoped_refptr<StreamTextureFactorySynchronousImpl> factory(
       StreamTextureFactorySynchronousImpl::Create(
           base::Bind(
               &SynchronousCompositorFactoryImpl::TryCreateStreamTextureFactory,
               base::Unretained(this)),
           frame_id));
   return factory;
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl*
 SynchronousCompositorFactoryImpl::CreateOffscreenGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes) {
+  DCHECK(!use_ipc_command_buffer_);
   ContextHolder holder =
       CreateContextHolder(attributes, GpuThreadService(),
                           gpu::GLInProcessContextSharedMemoryLimits(), true);
   return holder.command_buffer.release();
 }
 
 gpu::GPUInfo SynchronousCompositorFactoryImpl::GetGPUInfo() const {
+  DCHECK(!use_ipc_command_buffer_);
   return content::GpuDataManager::GetInstance()->GetGPUInfo();
 }
 
 void SynchronousCompositorFactoryImpl::CompositorInitializedHardwareDraw() {
   base::AutoLock lock(num_hardware_compositor_lock_);
   num_hardware_compositors_++;
   if (num_hardware_compositors_ == 1 && main_thread_task_runner_.get()) {
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
@@ skipping 74 matching lines @@
         android_view_service_->sync_point_manager());
   }
   return gpu_thread_service_;
 }
 
 void SynchronousCompositorFactoryImpl::SetRecordFullDocument(
     bool record_full_document) {
   record_full_layer_ = record_full_document;
 }
 
+void SynchronousCompositorFactoryImpl::SetUseIpcCommandBuffer() {
+  use_ipc_command_buffer_ = true;
+}
+
 }  // namespace content