Share context creation logic with sync compositor

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 951 matching lines @@
 
 GURL RenderWidget::GetURLForGraphicsContext3D() {
   return GURL();
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface(bool fallback) {
   // For widgets that are never visible, we don't start the compositor, so we
   // never get a request for a cc::OutputSurface.
   DCHECK(!compositor_never_visible_);
 
-#if defined(OS_ANDROID)
-  if (SynchronousCompositorFactory* factory =
-      SynchronousCompositorFactory::GetInstance()) {
-    return factory->CreateOutputSurface(routing_id(),
-                                        frame_swap_message_queue_);
-  }
-#endif
-
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   scoped_refptr<ContextProviderCommandBuffer> worker_context_provider;
   if (!use_software) {
     context_provider = ContextProviderCommandBuffer::Create(
         CreateGraphicsContext3D(true), RENDER_COMPOSITOR_CONTEXT);
     if (!context_provider.get()) {
       // Cause the compositor to wait and try again.
       return nullptr;
     }
     worker_context_provider =
         RenderThreadImpl::current()->SharedWorkerContextProvider();
     if (!worker_context_provider) {
       // Cause the compositor to wait and try again.
       return nullptr;
     }
+
+#if defined(OS_ANDROID)
+    if (SynchronousCompositorFactory* factory =
+            SynchronousCompositorFactory::GetInstance()) {
+      return factory->CreateOutputSurface(
+          routing_id(), frame_swap_message_queue_, context_provider,
+          worker_context_provider);
+    }
+#endif
   }
 
   uint32 output_surface_id = next_output_surface_id_++;
   // Composite-to-mailbox is currently used for layout tests in order to cause
   // them to draw inside in the renderer to do the readback there. This should
   // no longer be the case when crbug.com/311404 is fixed.
   if (!RenderThreadImpl::current() ||
       !RenderThreadImpl::current()->layout_test_mode()) {
     DCHECK(compositor_deps_->GetCompositorImplThreadTaskRunner());
     return make_scoped_ptr(new DelegatedCompositorOutputSurface(
@@ skipping 1307 matching lines @@
   // disparities we explicitly disable antialiasing.
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.antialias = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
   attributes.depth = false;
   attributes.stencil = false;
   bool lose_context_when_out_of_memory = true;
   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
 #if defined(OS_ANDROID)
+  // Synchronous compositor uses half because synchronous compositor
+  // pipeline is only one frame deep. But twice of half for low end
+  // because 16bit texture is not supported.

[no sievers, 2015/10/13 18:52:07]

nit: can you move the comment to below where we set |divider|?

+  bool using_synchronous_compositing =
+      SynchronousCompositorFactory::GetInstance();
   // If we raster too fast we become upload bound, and pending
   // uploads consume memory. For maximum upload throughput, we would
   // want to allow for upload_throughput * pipeline_time of pending
   // uploads, after which we are just wasting memory. Since we don't
   // know our upload throughput yet, this just caps our memory usage.
-  size_t divider = 1;
+  size_t divider = using_synchronous_compositing ? 2 : 1;
   if (base::SysInfo::IsLowEndDevice())
     divider = 6;
   // For reference Nexus10 can upload 1MB in about 2.5ms.
   const double max_mb_uploaded_per_ms = 2.0 / (5 * divider);
   // Deadline to draw a frame to achieve 60 frames per second.
   const size_t kMillisecondsPerFrame = 16;
   // Assuming a two frame deep pipeline between the CPU and the GPU.
   size_t max_transfer_buffer_usage_mb =
       static_cast<size_t>(2 * kMillisecondsPerFrame * max_mb_uploaded_per_ms);
   static const size_t kBytesPerMegabyte = 1024 * 1024;
@@ skipping 35 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content