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 203 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)
+    LOG(FATAL) << "Shouldn't use software compositing on ChromeOS.";
+#endif
 
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
         new SoftwareBrowserCompositorOutputSurface(
             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