Delete OnscreenDisplayClient and TopLevelDisplayClient.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 
@@ skipping 21 matching lines @@
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/scheduler/begin_frame_source.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_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator_android.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
@@ skipping 433 matching lines @@
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
   if (!visible) {
     DCHECK(host_->visible());
     host_->SetVisible(false);
     if (!host_->output_surface_lost())
       host_->ReleaseOutputSurface();
     pending_swapbuffers_ = 0;
     establish_gpu_channel_timeout_.Stop();
-    display_client_.reset();
+    display_.reset();
   } else {
     host_->SetVisible(true);
     if (output_surface_request_pending_)
       RequestNewOutputSurface();
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   device_scale_factor_ = factor;
   if (host_)
     host_->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
     host_->SetViewportSize(size);
-  if (display_client_)
-    display_client_->display()->Resize(size);
+  if (display_)
+    display_->Resize(size);
   root_layer_->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool flag) {
   has_transparent_background_ = flag;
   if (host_)
     host_->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
@@ skipping 61 matching lines @@
 void CompositorImpl::CreateOutputSurface() {
   // We might have had a request from a LayerTreeHost that was then
   // hidden (and hidden means we don't have a native surface).
   // Also make sure we only handle this once.
   if (!output_surface_request_pending_ || !host_->visible())
     return;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
       SharedVulkanContextProviderAndroid();
-  std::unique_ptr<cc::OutputSurface> real_output_surface;
+  std::unique_ptr<cc::OutputSurface> display_output_surface;
 #if defined(ENABLE_VULKAN)
   std::unique_ptr<VulkanOutputSurface> vulkan_surface;
   if (vulkan_context_provider) {
     vulkan_surface.reset(new VulkanOutputSurface(
         std::move(vulkan_context_provider),
         base::WrapUnique(new ExternalBeginFrameSource(this))));
     if (!vulkan_surface->Initialize(window_)) {
       vulkan_surface->Destroy();
       vulkan_surface.reset();
     } else {
-      real_output_surface = std::move(vulkan_surface);
+      display_output_surface = std::move(vulkan_surface);
     }
   }
 #endif
 
-  if (!real_output_surface) {
+  if (!display_output_surface) {
     // This is used for the browser compositor (offscreen) and for the display
     // compositor (onscreen), so ask for capabilities needed by either one.
     // The default framebuffer for an offscreen context is not used, so it does
     // not need alpha, stencil, depth, antialiasing. The display compositor does
     // not use these things either, except for alpha when it has a transparent
     // background.
     gpu::gles2::ContextCreationAttribHelper attributes;
     attributes.alpha_size = -1;
     attributes.stencil_size = 0;
     attributes.depth_size = 0;
@@ skipping 57 matching lines @@
     limits.mapped_memory_reclaim_limit = full_screen_texture_size_in_bytes;
 
     context_provider = new ContextProviderCommandBuffer(
         std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
         gpu::GpuStreamPriority::NORMAL, surface_handle_, url,
         gl::PreferIntegratedGpu, automatic_flushes, support_locking, limits,
         attributes, nullptr,
         command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
     DCHECK(context_provider.get());
 
-    real_output_surface = base::WrapUnique(new OutputSurfaceWithoutParent(
+    display_output_surface = base::WrapUnique(new OutputSurfaceWithoutParent(
         this, context_provider,
         base::Bind(&CompositorImpl::PopulateGpuCapabilities,
                    base::Unretained(this)),
         base::WrapUnique(new ExternalBeginFrameSource(this))));
   }
 
   cc::SurfaceManager* manager = GetSurfaceManager();
-  display_client_.reset(new cc::OnscreenDisplayClient(
-      std::move(real_output_surface), manager,
-      HostSharedBitmapManager::current(),
-      BrowserGpuMemoryBufferManager::current(),
-      host_->settings().renderer_settings, base::ThreadTaskRunnerHandle::Get(),
-      surface_id_allocator_->id_namespace()));
+  display_.reset(new cc::Display(manager, HostSharedBitmapManager::current(),
+                                 BrowserGpuMemoryBufferManager::current(),
+                                 host_->settings().renderer_settings,
+                                 surface_id_allocator_->id_namespace(),
+                                 base::ThreadTaskRunnerHandle::Get().get(),
+                                 std::move(display_output_surface)));
 
-  std::unique_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
+  std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
       vulkan_context_provider
           ? new cc::SurfaceDisplayOutputSurface(
-                manager, surface_id_allocator_.get(),
+                manager, surface_id_allocator_.get(), display_.get(),
                 static_cast<scoped_refptr<cc::VulkanContextProvider>>(
                     vulkan_context_provider))
-          : new cc::SurfaceDisplayOutputSurface(manager,
-                                                surface_id_allocator_.get(),
-                                                context_provider, nullptr));
+          : new cc::SurfaceDisplayOutputSurface(
+                manager, surface_id_allocator_.get(), display_.get(),
+                context_provider, nullptr));
 
-  display_client_->set_surface_output_surface(surface_output_surface.get());
-  surface_output_surface->set_display_client(display_client_.get());
-  display_client_->display()->Resize(size_);
-  host_->SetOutputSurface(std::move(surface_output_surface));
+  display_->Resize(size_);
+  host_->SetOutputSurface(std::move(delegated_output_surface));
 }
 
 void CompositorImpl::PopulateGpuCapabilities(
     gpu::Capabilities gpu_capabilities) {
   gpu_capabilities_ = gpu_capabilities;
 }
 
 void CompositorImpl::AddObserver(VSyncObserver* observer) {
   observer_list_.AddObserver(observer);
 }
@@ skipping 68 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content