Delete OnscreenDisplayClient and TopLevelDisplayClient.

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"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/base/histograms.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/raster/task_graph_runner.h"
-#include "cc/surfaces/onscreen_display_client.h"
+#include "cc/surfaces/display.h"
 #include "cc/surfaces/surface_display_output_surface.h"
 #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"
@@ skipping 106 matching lines @@
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kDisableMacOverlays);
 }
 #endif
 
 }  // namespace
 
 namespace content {
 
 struct GpuProcessTransportFactory::PerCompositorData {
-  gpu::SurfaceHandle surface_handle;
-  BrowserCompositorOutputSurface* surface;
-  ReflectorImpl* reflector;
-  std::unique_ptr<cc::OnscreenDisplayClient> display_client;
+  gpu::SurfaceHandle surface_handle = gpu::kNullSurfaceHandle;
+  BrowserCompositorOutputSurface* display_output_surface = nullptr;
+  ReflectorImpl* reflector = nullptr;
+  std::unique_ptr<cc::Display> display;
   bool output_is_secure = false;
-
-  PerCompositorData()
-      : surface_handle(gpu::kNullSurfaceHandle),
-        surface(nullptr),
-        reflector(nullptr) {}
 };
 
 GpuProcessTransportFactory::GpuProcessTransportFactory()
     : next_surface_id_namespace_(1u),
       task_graph_runner_(new cc::SingleThreadTaskGraphRunner),
       callback_factory_(this) {
   cc::SetClientNameForMetrics("Browser");
 
   surface_manager_ = base::WrapUnique(new cc::SurfaceManager);
 
@@ skipping 101 matching lines @@
   return GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor();
 }
 
 void GpuProcessTransportFactory::CreateOutputSurface(
     base::WeakPtr<ui::Compositor> compositor) {
   DCHECK(!!compositor);
   PerCompositorData* data = per_compositor_data_[compositor.get()];
   if (!data) {
     data = CreatePerCompositorData(compositor.get());
   } else {
-    data->surface = nullptr;
+    // TODO(danakj): We can destroy the |data->display| here when the compositor
+    // destroys its OutputSurface before calling back here.
+    data->display_output_surface = nullptr;
   }
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->UnregisterParent(
       compositor->widget());
 #endif
 
   const bool use_vulkan = static_cast<bool>(SharedVulkanContextProvider());
 
   const bool create_gpu_output_surface =
@@ skipping 121 matching lines @@
       // Try again.
       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
           CAUSE_FOR_GPU_LAUNCH_SHARED_WORKER_THREAD_CONTEXT,
           base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
                      callback_factory_.GetWeakPtr(), compositor,
                      create_gpu_output_surface, num_attempts + 1));
       return;
     }
   }
 
-  std::unique_ptr<BrowserCompositorOutputSurface> surface;
+  std::unique_ptr<BrowserCompositorOutputSurface> display_output_surface;
 #if defined(ENABLE_VULKAN)
   std::unique_ptr<VulkanBrowserCompositorOutputSurface> vulkan_surface;
   if (vulkan_context_provider) {
     vulkan_surface.reset(new VulkanBrowserCompositorOutputSurface(
         vulkan_context_provider, compositor->vsync_manager(),
         compositor->task_runner().get()));
     if (!vulkan_surface->Initialize(compositor.get()->widget())) {
       vulkan_surface->Destroy();
       vulkan_surface.reset();
     } else {
-      surface = std::move(vulkan_surface);
+      display_output_surface = std::move(vulkan_surface);
     }
   }
 #endif
 
-  if (!surface) {
+  if (!display_output_surface) {
     if (!create_gpu_output_surface) {
-      surface = base::WrapUnique(new SoftwareBrowserCompositorOutputSurface(
-          CreateSoftwareOutputDevice(compositor.get()),
-          compositor->vsync_manager(), compositor->task_runner().get()));
+      display_output_surface =
+          base::WrapUnique(new SoftwareBrowserCompositorOutputSurface(
+              CreateSoftwareOutputDevice(compositor.get()),
+              compositor->vsync_manager(), compositor->task_runner().get()));
     } else {
       DCHECK(context_provider);
       const auto& capabilities = context_provider->ContextCapabilities();
       if (data->surface_handle == gpu::kNullSurfaceHandle) {
-        surface = base::WrapUnique(new OffscreenBrowserCompositorOutputSurface(
-            context_provider, compositor->vsync_manager(),
-            compositor->task_runner().get(),
-            std::unique_ptr<
-                display_compositor::CompositorOverlayCandidateValidator>()));
+        display_output_surface =
+            base::WrapUnique(new OffscreenBrowserCompositorOutputSurface(
+                context_provider, compositor->vsync_manager(),
+                compositor->task_runner().get(),
+                std::unique_ptr<display_compositor::
+                                    CompositorOverlayCandidateValidator>()));
       } else if (capabilities.surfaceless) {
 #if defined(OS_MACOSX)
-        surface = base::WrapUnique(new GpuOutputSurfaceMac(
+        display_output_surface = base::WrapUnique(new GpuOutputSurfaceMac(
             context_provider, data->surface_handle, compositor->vsync_manager(),
             compositor->task_runner().get(),
             CreateOverlayCandidateValidator(compositor->widget()),
             BrowserGpuMemoryBufferManager::current()));
 #else
-        surface =
+        display_output_surface =
             base::WrapUnique(new GpuSurfacelessBrowserCompositorOutputSurface(
                 context_provider, data->surface_handle,
                 compositor->vsync_manager(), compositor->task_runner().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());
 #endif
-        surface = base::WrapUnique(new GpuBrowserCompositorOutputSurface(
-            context_provider, compositor->vsync_manager(),
-            compositor->task_runner().get(), std::move(validator)));
+        display_output_surface =
+            base::WrapUnique(new GpuBrowserCompositorOutputSurface(
+                context_provider, compositor->vsync_manager(),
+                compositor->task_runner().get(), std::move(validator)));
       }
     }
   }
 
-  data->surface = surface.get();
+  data->display_output_surface = display_output_surface.get();
   if (data->reflector)
-    data->reflector->OnSourceSurfaceReady(data->surface);
+    data->reflector->OnSourceSurfaceReady(data->display_output_surface);
 
 #if defined(OS_WIN)
   gfx::RenderingWindowManager::GetInstance()->DoSetParentOnChild(
       compositor->widget());
 #endif
 
-  // This gets a bit confusing. Here we have a ContextProvider in the |surface|
-  // configured to render directly to this widget. We need to make an
-  // OnscreenDisplayClient associated with that context, then return a
-  // SurfaceDisplayOutputSurface set up to draw to the display's surface.
-  cc::SurfaceManager* manager = surface_manager_.get();
-  std::unique_ptr<cc::OnscreenDisplayClient> display_client(
-      new cc::OnscreenDisplayClient(
-          std::move(surface), manager, HostSharedBitmapManager::current(),
-          BrowserGpuMemoryBufferManager::current(),
-          compositor->GetRendererSettings(), compositor->task_runner(),
-          compositor->surface_id_allocator()->id_namespace()));
+  // 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(),
+      compositor->task_runner().get(), std::move(display_output_surface));
 
-  std::unique_ptr<cc::SurfaceDisplayOutputSurface> 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(
-                manager, compositor->surface_id_allocator(),
+                surface_manager_.get(), compositor->surface_id_allocator(),
+                data->display.get(),
                 static_cast<scoped_refptr<cc::VulkanContextProvider>>(
                     vulkan_context_provider))
           : new cc::SurfaceDisplayOutputSurface(
-                manager, compositor->surface_id_allocator(), context_provider,
+                surface_manager_.get(), compositor->surface_id_allocator(),
+                data->display.get(), context_provider,
                 shared_worker_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());
-  display_client->display()->SetOutputIsSecure(data->output_is_secure);
-  data->display_client = std::move(display_client);
-  compositor->SetOutputSurface(std::move(output_surface));
+  data->display->Resize(compositor->size());
+  data->display->SetOutputIsSecure(data->output_is_secure);
+  compositor->SetOutputSurface(std::move(delegated_output_surface));
 }
 
 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));
   source_data->reflector = reflector.get();
-  if (BrowserCompositorOutputSurface* source_surface = source_data->surface)
+  if (auto* source_surface = source_data->display_output_surface)
     reflector->OnSourceSurfaceReady(source_surface);
   return std::move(reflector);
 }
 
 void GpuProcessTransportFactory::RemoveReflector(ui::Reflector* reflector) {
   ReflectorImpl* reflector_impl = static_cast<ReflectorImpl*>(reflector);
   PerCompositorData* data =
       per_compositor_data_[reflector_impl->mirrored_compositor()];
   DCHECK(data);
   data->reflector->Shutdown();
@@ skipping 70 matching lines @@
   return allocator;
 }
 
 void GpuProcessTransportFactory::ResizeDisplay(ui::Compositor* compositor,
                                                const gfx::Size& size) {
   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
   if (it == per_compositor_data_.end())
     return;
   PerCompositorData* data = it->second;
   DCHECK(data);
-  if (data->display_client)
-    data->display_client->display()->Resize(size);
+  if (data->display)
+    data->display->Resize(size);
 }
 
 void GpuProcessTransportFactory::SetAuthoritativeVSyncInterval(
     ui::Compositor* compositor,
     base::TimeDelta interval) {
   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
   if (it == per_compositor_data_.end())
     return;
   PerCompositorData* data = it->second;
   DCHECK(data);
-  if (data->surface) {
-    data->surface->begin_frame_source()->SetAuthoritativeVSyncInterval(
-        interval);
+  if (data->display_output_surface) {
+    data->display_output_surface->begin_frame_source()
+        ->SetAuthoritativeVSyncInterval(interval);
   }
 }
 
 void GpuProcessTransportFactory::SetOutputIsSecure(ui::Compositor* compositor,
                                                    bool secure) {
   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
   if (it == per_compositor_data_.end())
     return;
   PerCompositorData* data = it->second;
   DCHECK(data);
   data->output_is_secure = secure;
-  if (data->display_client)
-    data->display_client->display()->SetOutputIsSecure(secure);
+  if (data->display)
+    data->display->SetOutputIsSecure(secure);
 }
 
 cc::SurfaceManager* GpuProcessTransportFactory::GetSurfaceManager() {
   return surface_manager_.get();
 }
 
 display_compositor::GLHelper* GpuProcessTransportFactory::GetGLHelper() {
   if (!gl_helper_ && !per_compositor_data_.empty()) {
     scoped_refptr<cc::ContextProvider> provider =
         SharedMainThreadContextProvider();
@@ skipping 16 matching lines @@
 
 #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->surface)
-    data->surface->SetSurfaceSuspendedForRecycle(suspended);
+  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;
@@ skipping 85 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content