cc: Remove the unused compositor thread variable and interface.

Removes GetCompositorMessageLoop from the ContextFactory interface,
and drops the compositor_thread_ members from the ContextFactory
implementations.

There is no compositor thread in the ui compositor so these are now
excess complication.

R=sievers
BUG=329552

Review URL: https://codereview.chromium.org/943763004

Cr-Commit-Position: refs/heads/master@{#317622}

content/browser/compositor/gpu_process_transport_factory.cc

@@ -221,10 +221,9 @@ void GpuProcessTransportFactory::EstablishedGpuChannel(
   }
 
   if (!context_provider.get()) {
-    if (compositor_thread_.get()) {
-      LOG(FATAL) << "Failed to create UI context, but can't use software"
-                    " compositing with browser threaded compositing. Aborting.";
-    }
+#if defined(OS_CHROMEOS)
+    LOG(FATAL) << "Shouldn't use software compositing on ChromeOS.";
+#endif
 
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
         new SoftwareBrowserCompositorOutputSurface(
@@ -243,7 +242,6 @@ void GpuProcessTransportFactory::EstablishedGpuChannel(
         context_provider, data->surface_id, &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget()), GL_RGB,
-        compositor_thread_ != nullptr,
         BrowserGpuMemoryBufferManager::current()));
   }
 #endif
@@ -267,10 +265,8 @@ scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
   PerCompositorData* data = per_compositor_data_[source];
   DCHECK(data);
 
-  data->reflector = new ReflectorImpl(source,
-                                      target,
-                                      &output_surface_map_,
-                                      GetCompositorMessageLoop(),
+  data->reflector = new ReflectorImpl(source, target, &output_surface_map_,
+                                      nullptr,  // Compositor message loop.
                                       data->surface_id);
   return data->reflector;
 }
@@ -329,12 +325,6 @@ ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
   return this;
 }
 
-base::MessageLoopProxy* GpuProcessTransportFactory::GetCompositorMessageLoop() {
-  if (!compositor_thread_)
-    return NULL;
-  return compositor_thread_->message_loop_proxy().get();
-}
-
 gfx::GLSurfaceHandle GpuProcessTransportFactory::GetSharedSurfaceHandle() {
   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
       gfx::kNullPluginWindow, gfx::NULL_TRANSPORT);

content/browser/compositor/gpu_process_transport_factory.h

@@ -53,7 +53,6 @@ class GpuProcessTransportFactory
   bool DoesCreateTestContexts() override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
-  base::MessageLoopProxy* GetCompositorMessageLoop() override;
   scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() override;
   void ResizeDisplay(ui::Compositor* compositor,
                      const gfx::Size& size) override;
@@ -85,7 +84,6 @@ class GpuProcessTransportFactory
   void OnLostMainThreadSharedContext();
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
-  scoped_ptr<base::Thread> compositor_thread_;
   PerCompositorDataMap per_compositor_data_;
   scoped_refptr<ContextProviderCommandBuffer> shared_main_thread_contexts_;
   scoped_ptr<GLHelper> gl_helper_;

content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.cc

@@ -23,7 +23,6 @@ GpuSurfacelessBrowserCompositorOutputSurface::
         const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager,
         scoped_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator,
         unsigned internalformat,
-        bool use_own_gl_helper,
         BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager)
     : GpuBrowserCompositorOutputSurface(context,
                                         surface_id,
@@ -31,7 +30,6 @@ GpuSurfacelessBrowserCompositorOutputSurface::
                                         vsync_manager,
                                         overlay_candidate_validator.Pass()),
       internalformat_(internalformat),
-      use_own_gl_helper_(use_own_gl_helper),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager) {
   capabilities_.uses_default_gl_framebuffer = false;
   capabilities_.flipped_output_surface = true;
@@ -86,17 +84,9 @@ bool GpuSurfacelessBrowserCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* client) {
   if (!GpuBrowserCompositorOutputSurface::BindToClient(client))
     return false;
-  GLHelper* helper;
-  if (use_own_gl_helper_) {
-    gl_helper_.reset(new GLHelper(context_provider_->ContextGL(),
-                                  context_provider_->ContextSupport()));
-    helper = gl_helper_.get();
-  } else {
-    helper = ImageTransportFactory::GetInstance()->GetGLHelper();
-  }
+  GLHelper* helper = ImageTransportFactory::GetInstance()->GetGLHelper();
   if (!helper)
     return false;
-
   output_surface_.reset(new BufferQueue(context_provider_, internalformat_,
                                         helper, gpu_memory_buffer_manager_,
                                         surface_id_));

content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h

@@ -11,7 +11,6 @@ namespace content {
 
 class BrowserGpuMemoryBufferManager;
 class BufferQueue;
-class GLHelper;
 
 class GpuSurfacelessBrowserCompositorOutputSurface
     : public GpuBrowserCompositorOutputSurface {
@@ -23,7 +22,6 @@ class GpuSurfacelessBrowserCompositorOutputSurface
       const scoped_refptr<ui::CompositorVSyncManager>& vsync_manager,
       scoped_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator,
       unsigned internalformat,
-      bool use_own_gl_helper,
       BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager);
   ~GpuSurfacelessBrowserCompositorOutputSurface() override;
 
@@ -36,8 +34,6 @@ class GpuSurfacelessBrowserCompositorOutputSurface
   bool BindToClient(cc::OutputSurfaceClient* client) override;
 
   unsigned int internalformat_;
-  bool use_own_gl_helper_;
-  scoped_ptr<GLHelper> gl_helper_;
   scoped_ptr<BufferQueue> output_surface_;
   BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager_;
 };

content/browser/renderer_host/render_widget_host_view_browsertest.cc

@@ -942,16 +942,24 @@ IN_PROC_BROWSER_TEST_P(
                                 video_frame);
 }
 
+#if defined(OS_CHROMEOS)
+// On ChromeOS there is no software compositing.
+static const auto kTestCompositingModes = testing::Values(GL_COMPOSITING);
+#else
+static const auto kTestCompositingModes =
+    testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING);
+#endif
+
 INSTANTIATE_TEST_CASE_P(GLAndSoftwareCompositing,
                         CompositingRenderWidgetHostViewBrowserTest,
-                        testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+                        kTestCompositingModes);
 INSTANTIATE_TEST_CASE_P(GLAndSoftwareCompositing,
                         CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                        testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+                        kTestCompositingModes);
 INSTANTIATE_TEST_CASE_P(
     GLAndSoftwareCompositing,
     CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI,
-    testing::Values(GL_COMPOSITING, SOFTWARE_COMPOSITING));
+    kTestCompositingModes);
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 

content/browser/screen_orientation/screen_orientation_browsertest.cc

@@ -32,14 +32,6 @@ class ScreenOrientationBrowserTest : public ContentBrowserTest  {
   ScreenOrientationBrowserTest() {
   }
 
-  void SetUp() override {
-    // Painting has to happen otherwise the Resize messages will be added on top
-    // of each other without properly ack-painting which will fail and crash.
-    UseSoftwareCompositing();
-
-    ContentBrowserTest::SetUp();
-  }
-
  protected:
   void SendFakeScreenOrientation(unsigned angle, const std::string& strType) {
     RenderWidgetHost* rwh = shell()->web_contents()->GetRenderWidgetHostView()

content/child/child_discardable_shared_memory_manager_browsertest.cc

@@ -15,6 +15,10 @@
 
 namespace content {
 
+// ChromeOS does not do software compositing, so kDisableGpu is not available
+// there.
+#if !defined(OS_CHROMEOS)
+
 class ChildDiscardableSharedMemoryManagerBrowserTest
     : public ContentBrowserTest {
  public:
@@ -118,4 +122,6 @@ IN_PROC_BROWSER_TEST_F(ChildDiscardableSharedMemoryManagerBrowserTest,
   }
 }
 
+#endif  // !OS_CHROMEOS
+
 }  // content

ui/compositor/compositor.cc

@@ -72,7 +72,6 @@ Compositor::Compositor(gfx::AcceleratedWidget widget,
       root_layer_(NULL),
       widget_(widget),
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
-      compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
@@ -137,25 +136,10 @@ Compositor::Compositor(gfx::AcceleratedWidget widget,
   settings.hud_typeface = ui::GetHudTypeface();
 
   base::TimeTicks before_create = base::TimeTicks::Now();
-  if (compositor_thread_loop_.get()) {
-    host_ = cc::LayerTreeHost::CreateThreaded(
-        this,
-        context_factory_->GetSharedBitmapManager(),
-        context_factory_->GetGpuMemoryBufferManager(),
-        settings,
-        task_runner_,
-        compositor_thread_loop_,
-        nullptr);
-  } else {
-    host_ = cc::LayerTreeHost::CreateSingleThreaded(
-        this,
-        this,
-        context_factory_->GetSharedBitmapManager(),
-        context_factory_->GetGpuMemoryBufferManager(),
-        settings,
-        task_runner_,
-        nullptr);
-  }
+  host_ = cc::LayerTreeHost::CreateSingleThreaded(
+      this, this, context_factory_->GetSharedBitmapManager(),
+      context_factory_->GetGpuMemoryBufferManager(), settings, task_runner_,
+      nullptr);
   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
                       base::TimeTicks::Now() - before_create);
   host_->SetRootLayer(root_web_layer_);
@@ -354,14 +338,6 @@ void Compositor::DidCommitAndDrawFrame() {
 }
 
 void Compositor::DidCompleteSwapBuffers() {
-  // DidPostSwapBuffers is a SingleThreadProxy-only feature.  Synthetically
-  // generate OnCompositingStarted messages for the threaded case so that
-  // OnCompositingStarted/OnCompositingEnded messages match.
-  if (compositor_thread_loop_.get()) {
-    base::TimeTicks start_time = gfx::FrameTime::Now();
-    FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
-                      OnCompositingStarted(this, start_time));
-  }
   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingEnded(this));
 }

ui/compositor/compositor.h

@@ -97,10 +97,6 @@ class COMPOSITOR_EXPORT ContextFactory {
   // Gets the GPU memory buffer manager.
   virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
 
-  // Gets the compositor message loop, or NULL if not using threaded
-  // compositing.
-  virtual base::MessageLoopProxy* GetCompositorMessageLoop() = 0;
-
   // Creates a Surface ID allocator with a new namespace.
   virtual scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() = 0;
 
@@ -315,7 +311,6 @@ class COMPOSITOR_EXPORT Compositor
   scoped_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
   scoped_refptr<cc::Layer> root_web_layer_;
   scoped_ptr<cc::LayerTreeHost> host_;
-  scoped_refptr<base::MessageLoopProxy> compositor_thread_loop_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // The manager of vsync parameters for this compositor.

ui/compositor/test/in_process_context_factory.cc

@@ -179,12 +179,6 @@ InProcessContextFactory::GetGpuMemoryBufferManager() {
   return &gpu_memory_buffer_manager_;
 }
 
-base::MessageLoopProxy* InProcessContextFactory::GetCompositorMessageLoop() {
-  if (!compositor_thread_)
-    return NULL;
-  return compositor_thread_->message_loop_proxy().get();
-}
-
 scoped_ptr<cc::SurfaceIdAllocator>
 InProcessContextFactory::CreateSurfaceIdAllocator() {
   return make_scoped_ptr(

ui/compositor/test/in_process_context_factory.h

@@ -47,13 +47,11 @@ class InProcessContextFactory : public ContextFactory {
   bool DoesCreateTestContexts() override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
-  base::MessageLoopProxy* GetCompositorMessageLoop() override;
   scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() override;
   void ResizeDisplay(ui::Compositor* compositor,
                      const gfx::Size& size) override;
 
  private:
-  scoped_ptr<base::Thread> compositor_thread_;
   scoped_refptr<cc::ContextProvider> shared_main_thread_contexts_;
   cc::TestSharedBitmapManager shared_bitmap_manager_;
   cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;