cc: Remove the unused compositor thread variable and interface.

content/browser/compositor/gpu_process_transport_factory.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/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 169 matching lines @@
         GpuProcessTransportFactory::CreateContextCommon(gpu_channel_host,
                                                         data->surface_id),
         "Compositor");
   }
 
   UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
                         !!context_provider.get());
 
   if (context_provider.get()) {
     scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
-        GetCompositorMessageLoop();
-    if (!compositor_thread_task_runner.get())
-      compositor_thread_task_runner = base::MessageLoopProxy::current();
+        base::MessageLoopProxy::current();
 
     // Here we know the GpuProcessHost has been set up, because we created a
     // context.
     output_surface_proxy_->ConnectToGpuProcessHost(
         compositor_thread_task_runner.get());
   }
 
   if (UseSurfacesEnabled()) {
     // This gets a bit confusing. Here we have a ContextProvider configured to
     // render directly to this widget. We need to make an OnscreenDisplayClient
@@ skipping 28 matching lines @@
             manager, compositor->surface_id_allocator(), context_provider));
     display_client->set_surface_output_surface(output_surface.get());
     output_surface->set_display_client(display_client.get());
     display_client->display()->Resize(compositor->size());
     data->display_client = display_client.Pass();
     compositor->SetOutputSurface(output_surface.Pass());
     return;
   }
 
   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)
+    NOTREACHED() << "Shouldn't use software compositing on ChromeOS.";

[no sievers, 2015/02/20 02:14:31]

So with threaded compositing we would get crash reports previously on CrOS for
reaching this. After switching to single-threaded compositing, we then allowed
this to fall back to software here even on CrOS?
I guess we now still do allow fallback to sw in release builds, but not debug
builds. Although we wouldn't run the unittests anymore with this patch, so
things might break. Should we always totally explode here then maybe?

And do you want to DCHECK(!create_software_renderer) for CrOS above?

[danakj, 2015/02/20 03:32:08]

ya we did because of those tests which I just fixed in this CL to not software
composite on CrOS.
Ya good idea, I'll LOG(FATAL) back again.
It seems a little bit overkill maybe? I could if you feel strongly.

+#endif
 
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
         new SoftwareBrowserCompositorOutputSurface(
             output_surface_proxy_,
             CreateSoftwareOutputDevice(compositor.get()),
             data->surface_id,
             &output_surface_map_,
             compositor->vsync_manager()));
     compositor->SetOutputSurface(surface.Pass());
     return;
   }
 
   scoped_ptr<BrowserCompositorOutputSurface> surface;
 #if defined(USE_OZONE)
   if (ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) {
     surface.reset(new GpuSurfacelessBrowserCompositorOutputSurface(
         context_provider, data->surface_id, &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget()), GL_RGB,
-        compositor_thread_ != nullptr,
         BrowserGpuMemoryBufferManager::current()));
   }
 #endif
   if (!surface)
     surface.reset(new GpuBrowserCompositorOutputSurface(
         context_provider,
         data->surface_id,
         &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget())));
 
   if (data->reflector.get())
     data->reflector->ReattachToOutputSurfaceFromMainThread(surface.get());
 
   compositor->SetOutputSurface(surface.Pass());
 }
 
 scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source,
     ui::Layer* target) {
   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;
 }
 
 void GpuProcessTransportFactory::RemoveReflector(
     scoped_refptr<ui::Reflector> reflector) {
   ReflectorImpl* reflector_impl =
       static_cast<ReflectorImpl*>(reflector.get());
   PerCompositorData* data =
       per_compositor_data_[reflector_impl->mirrored_compositor()];
@@ skipping 38 matching lines @@
 
 gpu::GpuMemoryBufferManager*
 GpuProcessTransportFactory::GetGpuMemoryBufferManager() {
   return BrowserGpuMemoryBufferManager::current();
 }
 
 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);
   handle.parent_client_id =
       BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
   return handle;
 }
 
 scoped_ptr<cc::SurfaceIdAllocator>
 GpuProcessTransportFactory::CreateSurfaceIdAllocator() {
@@ skipping 164 matching lines @@
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content