gpu: Introduce GpuChannelEstablishFactory.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 21 matching lines @@
 #include "cc/surfaces/surface_manager.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
 #include "content/browser/compositor/gpu_browser_compositor_output_surface.h"
 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
 #include "content/browser/compositor/offscreen_browser_compositor_output_surface.h"
 #include "content/browser/compositor/reflector_impl.h"
 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
 #include "content/browser/compositor/software_output_device_mus.h"
-#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
+#include "services/shell/runner/common/client_util.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_constants.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/geometry/size.h"
 
-#if defined(MOJO_RUNNER_CLIENT)
+#if defined(USE_AURA)
 #include "content/browser/compositor/mus_browser_compositor_output_surface.h"
 #include "content/public/common/mojo_shell_connection.h"
-#include "services/shell/runner/common/client_util.h"
 #include "services/ui/common/gpu_service.h"
 #endif
 
 #if defined(OS_WIN)
 #include "content/browser/compositor/software_output_device_win.h"
 #include "ui/gfx/win/rendering_window_manager.h"
 #elif defined(USE_OZONE)
 #include "components/display_compositor/compositor_overlay_candidate_validator_ozone.h"
 #include "content/browser/compositor/software_output_device_ozone.h"
 #include "ui/ozone/public/overlay_candidates_ozone.h"
@@ skipping 22 matching lines @@
 #endif
 
 using cc::ContextProvider;
 using gpu::gles2::GLES2Interface;
 
 namespace {
 
 const int kNumRetriesBeforeSoftwareFallback = 4;
 
 bool IsUsingMus() {
-#if defined(MOJO_RUNNER_CLIENT)
   return shell::ShellIsRemote();
-#else
-  return false;
-#endif
 }
 
 scoped_refptr<content::ContextProviderCommandBuffer> CreateContextCommon(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
     gpu::SurfaceHandle surface_handle,
     bool need_alpha_channel,
     bool support_locking,
     content::ContextProviderCommandBuffer* shared_context_provider,
     content::command_buffer_metrics::ContextType type) {
   DCHECK(
@@ skipping 76 matching lines @@
 
   // Make sure the lost context callback doesn't try to run during destruction.
   callback_factory_.InvalidateWeakPtrs();
 
   task_graph_runner_->Shutdown();
 }
 
 std::unique_ptr<cc::SoftwareOutputDevice>
 GpuProcessTransportFactory::CreateSoftwareOutputDevice(
     ui::Compositor* compositor) {
-#if defined(MOJO_RUNNER_CLIENT)
+#if defined(USE_AURA)
   if (shell::ShellIsRemote()) {
     return std::unique_ptr<cc::SoftwareOutputDevice>(
         new SoftwareOutputDeviceMus(compositor));
   }
 #endif
 
 #if defined(OS_WIN)
   return std::unique_ptr<cc::SoftwareOutputDevice>(
       new SoftwareOutputDeviceWin(software_backing_.get(), compositor));
 #elif defined(USE_OZONE)
@@ skipping 76 matching lines @@
     data->display_output_surface = nullptr;
     data->begin_frame_source = nullptr;
   }
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->UnregisterParent(
       compositor->widget());
 #endif
 
   const bool use_vulkan = static_cast<bool>(SharedVulkanContextProvider());
-  const bool use_mus = IsUsingMus();
   const bool create_gpu_output_surface =
       ShouldCreateGpuOutputSurface(compositor.get());
   if (create_gpu_output_surface && !use_vulkan) {
-    base::Closure callback(
+    gpu::GpuChannelEstablishedCallback callback(
         base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                    callback_factory_.GetWeakPtr(), compositor,
                    create_gpu_output_surface, 0));
-    if (!use_mus) {
-      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(callback);
-    } else {
-#if defined(MOJO_RUNNER_CLIENT)
-      ui::GpuService::GetInstance()->EstablishGpuChannel(callback);
-#else
-      NOTREACHED();
-#endif
-    }
+    DCHECK(gpu_channel_factory_);
+    gpu_channel_factory_->EstablishGpuChannel(callback);
   } else {
-    EstablishedGpuChannel(compositor, create_gpu_output_surface, 0);
+    EstablishedGpuChannel(compositor, create_gpu_output_surface, 0, nullptr);
   }
 }
 
 void GpuProcessTransportFactory::EstablishedGpuChannel(
     base::WeakPtr<ui::Compositor> compositor,
     bool create_gpu_output_surface,
-    int num_attempts) {
+    int num_attempts,
+    scoped_refptr<gpu::GpuChannelHost> established_channel_host) {
   if (!compositor)
     return;
 
   // The widget might have been released in the meantime.
   PerCompositorDataMap::iterator it =
       per_compositor_data_.find(compositor.get());
   if (it == per_compositor_data_.end())
     return;
 
   PerCompositorData* data = it->second;
   DCHECK(data);
 
   if (num_attempts > kNumRetriesBeforeSoftwareFallback) {
 #if defined(OS_CHROMEOS)
     LOG(FATAL) << "Unable to create a UI graphics context, and cannot use "
                << "software compositing on ChromeOS.";
 #endif
     create_gpu_output_surface = false;
   }
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->RegisterParent(
       compositor->widget());
 #endif
 
   scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
       SharedVulkanContextProvider();
-  const bool use_mus = IsUsingMus();
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   if (create_gpu_output_surface && !vulkan_context_provider) {
     // Try to reuse existing worker context provider.
     if (shared_worker_context_provider_) {
       bool lost;
       {
         // Note: If context is lost, we delete reference after releasing the
         // lock.
         base::AutoLock lock(*shared_worker_context_provider_->GetLock());
         lost = shared_worker_context_provider_->ContextGL()
                    ->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
       }
       if (lost)
         shared_worker_context_provider_ = nullptr;
     }
 
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
-    if (GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor()) {
-      // We attempted to do EstablishGpuChannel already, so we just use
-      // GetGpuChannel() instead of EstablishGpuChannelSync().
-      if (!use_mus) {
-        gpu_channel_host =
-            BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
-      } else {
-#if defined(MOJO_RUNNER_CLIENT)
-        gpu_channel_host = ui::GpuService::GetInstance()->GetGpuChannel();
-#else
-        NOTREACHED();
-#endif
-      }
-    }
+    if (GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
+      gpu_channel_host = std::move(established_channel_host);
 
     if (!gpu_channel_host) {
       shared_worker_context_provider_ = nullptr;
     } else {
       if (!shared_worker_context_provider_) {
         bool need_alpha_channel = false;
         const bool support_locking = true;
         shared_worker_context_provider_ =
             CreateContextCommon(gpu_channel_host, gpu::kNullSurfaceHandle,
                                 need_alpha_channel, support_locking, nullptr,
@@ skipping 44 matching lines @@
     }
 
     bool created_gpu_browser_compositor =
         !!context_provider && !!shared_worker_context_provider_;
 
     UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
                           created_gpu_browser_compositor);
 
     if (!created_gpu_browser_compositor) {
       // Try again.
-      base::Closure callback(
+      gpu::GpuChannelEstablishedCallback callback(
           base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                      callback_factory_.GetWeakPtr(), compositor,
                      create_gpu_output_surface, num_attempts + 1));
-      if (!use_mus) {
-        BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(callback);
-      } else {
-#if defined(MOJO_RUNNER_CLIENT)
-        ui::GpuService::GetInstance()->EstablishGpuChannel(callback);
-#else
-        NOTREACHED();
-#endif
-      }
+      DCHECK(gpu_channel_factory_);
+      gpu_channel_factory_->EstablishGpuChannel(callback);
       return;
     }
   }
 
   std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source;
   if (!compositor->GetRendererSettings().disable_display_vsync) {
     begin_frame_source.reset(new cc::DelayBasedBeginFrameSource(
         base::MakeUnique<cc::DelayBasedTimeSource>(
             compositor->task_runner().get())));
   } else {
@@ skipping 46 matching lines @@
             base::WrapUnique(new GpuSurfacelessBrowserCompositorOutputSurface(
                 context_provider, data->surface_handle,
                 compositor->vsync_manager(), begin_frame_source.get(),
                 CreateOverlayCandidateValidator(compositor->widget()),
                 GL_TEXTURE_2D, GL_RGB,
                 BrowserGpuMemoryBufferManager::current()));
 #endif
       } else {
         std::unique_ptr<display_compositor::CompositorOverlayCandidateValidator>
             validator;
+        const bool use_mus = IsUsingMus();
 #if !defined(OS_MACOSX)
         // Overlays are only supported on surfaceless output surfaces on Mac.
         if (!use_mus)
           validator = CreateOverlayCandidateValidator(compositor->widget());
 #endif
         if (!use_mus) {
           display_output_surface =
               base::WrapUnique(new GpuBrowserCompositorOutputSurface(
                   context_provider, compositor->vsync_manager(),
                   begin_frame_source.get(), std::move(validator)));
         } else {
-#if defined(MOJO_RUNNER_CLIENT)
+#if defined(USE_AURA)
           display_output_surface =
               base::WrapUnique(new MusBrowserCompositorOutputSurface(
                   data->surface_handle, context_provider,
                   compositor->vsync_manager(), begin_frame_source.get(),
                   std::move(validator)));
 #else
           NOTREACHED();
 #endif
         }
       }
@@ skipping 210 matching lines @@
   if (!gl_helper_ && !per_compositor_data_.empty()) {
     scoped_refptr<cc::ContextProvider> provider =
         SharedMainThreadContextProvider();
     if (provider.get())
       gl_helper_.reset(new display_compositor::GLHelper(
           provider->ContextGL(), provider->ContextSupport()));
   }
   return gl_helper_.get();
 }
 
+void GpuProcessTransportFactory::SetGpuChannelEstablishFactory(
+    gpu::GpuChannelEstablishFactory* factory) {
+  DCHECK(!gpu_channel_factory_ || !factory);
+  gpu_channel_factory_ = factory;
+}
+
 #if defined(OS_MACOSX)
 void GpuProcessTransportFactory::SetCompositorSuspendedForRecycle(
     ui::Compositor* compositor,
     bool suspended) {
   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
   if (it == per_compositor_data_.end())
     return;
   PerCompositorData* data = it->second;
   DCHECK(data);
   if (data->display_output_surface)
     data->display_output_surface->SetSurfaceSuspendedForRecycle(suspended);
 }
 #endif
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::SharedMainThreadContextProvider() {
   if (shared_main_thread_contexts_)
     return shared_main_thread_contexts_;
 
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
     return nullptr;
 
-  const bool use_mus = IsUsingMus();
-  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
-  if (!use_mus) {
-    gpu_channel_host =
-        BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync();
-  } else {
-#if defined(MOJO_RUNNER_CLIENT)
-    gpu_channel_host = ui::GpuService::GetInstance()->EstablishGpuChannelSync();
-#else
-    NOTREACHED();
-#endif
-  }
-
+  DCHECK(gpu_channel_factory_);
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
+      gpu_channel_factory_->EstablishGpuChannelSync();
   if (!gpu_channel_host)
     return nullptr;
 
   // We need a separate context from the compositor's so that skia and gl_helper
   // don't step on each other.
   bool need_alpha_channel = false;
   bool support_locking = false;
   shared_main_thread_contexts_ = CreateContextCommon(
       std::move(gpu_channel_host), gpu::kNullSurfaceHandle, need_alpha_channel,
       support_locking, nullptr,
@@ skipping 73 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content