WIP HW

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 42 matching lines @@
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/ipc/client/gpu_channel_host.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)
+#include "components/mus/common/gpu_service.h"
+#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"
 #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 175 matching lines @@
       new display_compositor::CompositorOverlayCandidateValidatorAndroid());
 #endif
 
   return validator;
 }
 
 static bool ShouldCreateGpuOutputSurface(ui::Compositor* compositor) {
 #if defined(MOJO_RUNNER_CLIENT)
   // Chrome running as a mojo app currently can only use software compositing.
   // TODO(rjkroege): http://crbug.com/548451
-  if (shell::ShellIsRemote()) {
-    return false;
-  }
+  if (shell::ShellIsRemote())
+    return mus::GpuService::UseChromeGpuCommandBuffer();
 #endif
 
 #if defined(OS_CHROMEOS)
   // Software fallback does not happen on Chrome OS.
   return true;
 #endif
 
 #if defined(OS_WIN)
   if (::GetProp(compositor->widget(), kForceSoftwareCompositor) &&
       ::RemoveProp(compositor->widget(), kForceSoftwareCompositor))
@@ skipping 15 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());
+#if defined(MOJO_RUNNER_CLIENT)
+  const bool use_mus = shell::ShellIsRemote();
+#else
+  const bool use_mus = false;
+#endif
 
   const bool create_gpu_output_surface =
       ShouldCreateGpuOutputSurface(compositor.get());
   if (create_gpu_output_surface && !use_vulkan) {
-    BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
-        CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT,
+    base::Closure callback(
         base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                    callback_factory_.GetWeakPtr(), compositor,
                    create_gpu_output_surface, 0));
+    if (!use_mus) {
+      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+          CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT, callback);
+#if defined(MOJO_RUNNER_CLIENT)
+    } else {
+      auto connector = MojoShellConnection::GetForProcess()->GetConnector();
+      mus::GpuService::GetInstance()->EstablishGpuChannel(connector, callback);
+#endif
+    }
   } else {
     EstablishedGpuChannel(compositor, create_gpu_output_surface, 0);
   }
 }
 
 void GpuProcessTransportFactory::EstablishedGpuChannel(
     base::WeakPtr<ui::Compositor> compositor,
     bool create_gpu_output_surface,
     int num_attempts) {
   if (!compositor)
@@ skipping 16 matching lines @@
     create_gpu_output_surface = false;
   }
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->RegisterParent(
       compositor->widget());
 #endif
 
   scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
       SharedVulkanContextProvider();
+#if defined(MOJO_RUNNER_CLIENT)
+  const bool use_mus = shell::ShellIsRemote();
+#else
+  const bool use_mus = false;
+#endif
 
   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().
-      gpu_channel_host =
-          BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+      if (!use_mus) {
+        gpu_channel_host =
+            BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+#if defined(MOJO_RUNNER_CLIENT)
+      } else {
+        gpu_channel_host = mus::GpuService::GetInstance()->GetGpuChannel();
+#endif
+      }
     }
 
     if (!gpu_channel_host) {
       shared_worker_context_provider_ = nullptr;
     } else {
       if (!shared_worker_context_provider_) {
         const bool support_locking = true;
         shared_worker_context_provider_ = CreateContextCommon(
             gpu_channel_host, gpu::kNullSurfaceHandle, support_locking, nullptr,
             command_buffer_metrics::BROWSER_WORKER_CONTEXT);
         // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is
         // fixed. Tracking time in BindToCurrentThread.
         tracked_objects::ScopedTracker tracking_profile(
             FROM_HERE_WITH_EXPLICIT_FUNCTION(
                 "125248"
                 " GpuProcessTransportFactory::EstablishedGpuChannel"
                 "::Worker"));
         if (!shared_worker_context_provider_->BindToCurrentThread())
           shared_worker_context_provider_ = nullptr;
       }
 
       // The |context_provider| is used for both the browser compositor and the
       // display compositor. It shares resources with the worker context, so if
       // we failed to make a worker context, just start over and try again.
       if (shared_worker_context_provider_) {
         bool support_locking = false;
+        // For mus, we create offscreen context.
         context_provider = CreateContextCommon(
-            std::move(gpu_channel_host), data->surface_handle, support_locking,
-            shared_worker_context_provider_.get(),
+            std::move(gpu_channel_host),
+            use_mus ? gpu::kNullSurfaceHandle : data->surface_handle,
+            support_locking, shared_worker_context_provider_.get(),
             command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
         // TODO(vadimt): Remove ScopedTracker below once crbug.com/125248 is
         // fixed. Tracking time in BindToCurrentThread.
         tracked_objects::ScopedTracker tracking_profile(
             FROM_HERE_WITH_EXPLICIT_FUNCTION(
                 "125248"
                 " GpuProcessTransportFactory::EstablishedGpuChannel"
                 "::Compositor"));
 #if defined(OS_MACOSX)
         // On Mac, GpuCommandBufferMsg_SwapBuffersCompleted must be handled in
         // a nested message loop during resize.
         context_provider->SetDefaultTaskRunner(
             ui::WindowResizeHelperMac::Get()->task_runner());
 #endif
         if (!context_provider->BindToCurrentThread())
           context_provider = nullptr;
       }
     }
 
     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.
-      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
-          CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT,
+      base::Closure callback(
           base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                      callback_factory_.GetWeakPtr(), compositor,
                      create_gpu_output_surface, num_attempts + 1));
+      if (!use_mus) {
+        BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+            CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT, callback);
+#if defined(MOJO_RUNNER_CLIENT)
+      } else {
+        auto connector = MojoShellConnection::GetForProcess()->GetConnector();
+        mus::GpuService::GetInstance()->EstablishGpuChannel(connector,
+                                                            callback);
+#endif
+      }
       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 48 matching lines @@
                 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;
 #if !defined(OS_MACOSX)
         // Overlays are only supported on surfaceless output surfaces on Mac.
-        validator = CreateOverlayCandidateValidator(compositor->widget());
+// validator = CreateOverlayCandidateValidator(compositor->widget());
 #endif
-        display_output_surface =
-            base::WrapUnique(new GpuBrowserCompositorOutputSurface(
-                context_provider, compositor->vsync_manager(),
-                begin_frame_source.get(), std::move(validator)));
+        if (!use_mus) {
+          display_output_surface =
+              base::WrapUnique(new GpuBrowserCompositorOutputSurface(
+                  context_provider, compositor->vsync_manager(),
+                  begin_frame_source.get(), std::move(validator)));
+#if defined(MOJO_RUNNER_CLIENT)
+        } else {
+          display_output_surface =
+              base::WrapUnique(new MusBrowserCompositorOutputSurface(
+                  data->surface_handle, context_provider,
+                  compositor->vsync_manager(), begin_frame_source.get(),
+                  std::move(validator)));
+#endif
+        }
       }
     }
   }
 
   data->display_output_surface = display_output_surface.get();
   data->begin_frame_source = begin_frame_source.get();
   if (data->reflector)
     data->reflector->OnSourceSurfaceReady(data->display_output_surface);
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->DoSetParentOnChild(
       compositor->widget());
 #endif
 
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), compositor->task_runner().get(),
       display_output_surface->capabilities().max_frames_pending));
 
-  // The Display owns and uses the |display_output_surface| created above.
-  data->display = base::MakeUnique<cc::Display>(
-      surface_manager_.get(), HostSharedBitmapManager::current(),
-      BrowserGpuMemoryBufferManager::current(),
-      compositor->GetRendererSettings(),
-      compositor->surface_id_allocator()->id_namespace(),
-      std::move(begin_frame_source), std::move(display_output_surface),
-      std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>(
-                                compositor->task_runner().get()));
+  if (!(use_mus && create_gpu_output_surface)) {
+    // The Display owns and uses the |display_output_surface| created above.
+    data->display = base::MakeUnique<cc::Display>(
+        surface_manager_.get(), HostSharedBitmapManager::current(),
+        BrowserGpuMemoryBufferManager::current(),
+        compositor->GetRendererSettings(),
+        compositor->surface_id_allocator()->id_namespace(),
+        std::move(begin_frame_source), std::move(display_output_surface),
+        std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>(
+                                  compositor->task_runner().get()));
 
-  // The |delegated_output_surface| is given back to the compositor, it
-  // delegates to the Display as its root surface. Importantly, it shares the
-  // same ContextProvider as the Display's output surface.
-  std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
-      vulkan_context_provider
-          ? new cc::SurfaceDisplayOutputSurface(
-                surface_manager_.get(), compositor->surface_id_allocator(),
-                data->display.get(),
-                static_cast<scoped_refptr<cc::VulkanContextProvider>>(
-                    vulkan_context_provider))
-          : new cc::SurfaceDisplayOutputSurface(
-                surface_manager_.get(), compositor->surface_id_allocator(),
-                data->display.get(), context_provider,
-                shared_worker_context_provider_));
-  data->display->Resize(compositor->size());
-  data->display->SetOutputIsSecure(data->output_is_secure);
-  compositor->SetOutputSurface(std::move(delegated_output_surface));
+    // The |delegated_output_surface| is given back to the compositor, it
+    // delegates to the Display as its root surface. Importantly, it shares the
+    // same ContextProvider as the Display's output surface.
+    std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
+        vulkan_context_provider
+            ? new cc::SurfaceDisplayOutputSurface(
+                  surface_manager_.get(), compositor->surface_id_allocator(),
+                  data->display.get(),
+                  static_cast<scoped_refptr<cc::VulkanContextProvider>>(
+                      vulkan_context_provider))
+            : new cc::SurfaceDisplayOutputSurface(
+                  surface_manager_.get(), compositor->surface_id_allocator(),
+                  data->display.get(), context_provider,
+                  shared_worker_context_provider_));
+    data->display->Resize(compositor->size());
+    data->display->SetOutputIsSecure(data->output_is_secure);
+    compositor->SetOutputSurface(std::move(delegated_output_surface));
+#if defined(MOJO_RUNNER_CLIENT)
+  } else {
+    compositor->SetOutputSurface(std::move(display_output_surface));
+#endif
+  }
 }
 
 std::unique_ptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source_compositor,
     ui::Layer* target_layer) {
   PerCompositorData* source_data = per_compositor_data_[source_compositor];
   DCHECK(source_data);
 
   std::unique_ptr<ReflectorImpl> reflector(
       new ReflectorImpl(source_compositor, target_layer));
@@ skipping 156 matching lines @@
 }
 #endif
 
 scoped_refptr<cc::ContextProvider>
 GpuProcessTransportFactory::SharedMainThreadContextProvider() {
   if (shared_main_thread_contexts_)
     return shared_main_thread_contexts_;
 
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
     return nullptr;
-  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
-      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(
-          CAUSE_FOR_GPU_LAUNCH_BROWSER_SHARED_MAIN_THREAD_CONTEXT));
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
+
+#if defined(MOJO_RUNNER_CLIENT)
+  const bool use_mus = shell::ShellIsRemote();
+#else
+  const bool use_mus = false;
+#endif
+
+  if (!use_mus) {
+    gpu_channel_host =
+        BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(
+            CAUSE_FOR_GPU_LAUNCH_BROWSER_SHARED_MAIN_THREAD_CONTEXT);
+  } else {
+    auto connector = MojoShellConnection::GetForProcess()->GetConnector();
+    gpu_channel_host =
+        mus::GpuService::GetInstance()->EstablishGpuChannelSync(connector);
+  }
+
   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 support_locking = false;
   shared_main_thread_contexts_ = CreateContextCommon(
       std::move(gpu_channel_host), gpu::kNullSurfaceHandle, support_locking,
       nullptr, command_buffer_metrics::BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
   shared_main_thread_contexts_->SetLostContextCallback(base::Bind(
@@ skipping 72 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content