Delete OnscreenDisplayClient and TopLevelDisplayClient.

cc/surfaces/display.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 "cc/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_renderer.h"
-#include "cc/output/texture_mailbox_deleter.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_aggregator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/buffer_types.h"
 
 #if defined(ENABLE_VULKAN)
 #include "cc/output/vulkan_renderer.h"
 #endif
 
 namespace {
 
 class EmptyBeginFrameSource : public cc::BeginFrameSource {
  public:
   void DidFinishFrame(cc::BeginFrameObserver* obs,
                       size_t remaining_frames) override{};
   void AddObserver(cc::BeginFrameObserver* obs) override{};
   void RemoveObserver(cc::BeginFrameObserver* obs) override{};
 };
 
 }  // namespace
 
 namespace cc {
 
-Display::Display(DisplayClient* client,
-                 SurfaceManager* manager,
+Display::Display(SurfaceManager* manager,
                  SharedBitmapManager* bitmap_manager,
                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                  const RendererSettings& settings,
-                 uint32_t compositor_surface_namespace)
-    : client_(client),
-      surface_manager_(manager),
+                 uint32_t compositor_surface_namespace,
+                 base::SingleThreadTaskRunner* task_runner,
+                 std::unique_ptr<OutputSurface> output_surface)
+    : surface_manager_(manager),
       bitmap_manager_(bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       settings_(settings),
       compositor_surface_namespace_(compositor_surface_namespace),
-      device_scale_factor_(1.f),
-      swapped_since_resize_(false),
-      vsync_begin_frame_source_(nullptr),
-      observed_begin_frame_source_(nullptr) {
+      task_runner_(task_runner),
+      output_surface_(std::move(output_surface)),
+      texture_mailbox_deleter_(task_runner) {
   surface_manager_->AddObserver(this);
 }
 
 Display::~Display() {
   if (observed_begin_frame_source_)
     surface_manager_->UnregisterBeginFrameSource(observed_begin_frame_source_);
   surface_manager_->RemoveObserver(this);
   if (aggregator_) {
     for (const auto& id_entry : aggregator_->previous_contained_surfaces()) {
       Surface* surface = surface_manager_->GetSurfaceForId(id_entry.first);
       if (surface)
         surface->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
     }
   }
 }
 
-void Display::CreateScheduler(base::SingleThreadTaskRunner* task_runner) {
+void Display::CreateScheduler() {
   DCHECK(!scheduler_);
-  if (!task_runner) {
+  if (!task_runner_) {
     // WebView doesn't have a task runner or a real begin frame source,
     // so just create something fake here.
     internal_begin_frame_source_.reset(new EmptyBeginFrameSource());
     vsync_begin_frame_source_ = internal_begin_frame_source_.get();
     observed_begin_frame_source_ = vsync_begin_frame_source_;
   } else {
     DCHECK(vsync_begin_frame_source_);
 
     observed_begin_frame_source_ = vsync_begin_frame_source_;
     if (settings_.disable_display_vsync) {
       internal_begin_frame_source_.reset(
-          new BackToBackBeginFrameSource(task_runner));
+          new BackToBackBeginFrameSource(task_runner_));
       observed_begin_frame_source_ = internal_begin_frame_source_.get();
     }
   }
 
   scheduler_.reset(
-      new DisplayScheduler(this, observed_begin_frame_source_, task_runner,
+      new DisplayScheduler(this, observed_begin_frame_source_, task_runner_,
                            output_surface_->capabilities().max_frames_pending));
   surface_manager_->RegisterBeginFrameSource(observed_begin_frame_source_,
                                              compositor_surface_namespace_);
 }
 
-bool Display::Initialize(std::unique_ptr<OutputSurface> output_surface,
-                         base::SingleThreadTaskRunner* task_runner) {
-  DCHECK(!output_surface_);
-  output_surface_ = std::move(output_surface);
+bool Display::Initialize(DisplayClient* client) {
+  client_ = client;
   if (!output_surface_->BindToClient(this))
     return false;
-  texture_mailbox_deleter_.reset(new TextureMailboxDeleter(task_runner));
-  CreateScheduler(task_runner);
+  CreateScheduler();
   return true;
 }
 
-bool Display::InitializeSynchronous(
-    std::unique_ptr<OutputSurface> output_surface,
-    base::SingleThreadTaskRunner* task_runner) {
-  DCHECK(!output_surface_);
-  output_surface_ = std::move(output_surface);
+bool Display::InitializeSynchronous(DisplayClient* client) {
+  client_ = client;
   if (!output_surface_->BindToClient(this))
     return false;
-  texture_mailbox_deleter_.reset(new TextureMailboxDeleter(task_runner));
   // No scheduler created here.
   return true;
 }
 
 void Display::SetSurfaceId(SurfaceId id, float device_scale_factor) {
   DCHECK_EQ(id.id_namespace(), compositor_surface_namespace_);
   if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
     return;
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
@@ skipping 52 matching lines @@
       gpu_memory_buffer_manager_, nullptr, settings_.highp_threshold_min,
       settings_.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.use_gpu_memory_buffer_resources,
       std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
                             GL_TEXTURE_2D)));
 
   if (output_surface_->context_provider()) {
     std::unique_ptr<GLRenderer> renderer = GLRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
-        texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
+        &texture_mailbox_deleter_, settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
   } else if (output_surface_->vulkan_context_provider()) {
 #if defined(ENABLE_VULKAN)
     std::unique_ptr<VulkanRenderer> renderer = VulkanRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
-        texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
+        &texture_mailbox_deleter_, settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
 #else
     NOTREACHED();
 #endif
   } else {
     std::unique_ptr<SoftwareRenderer> renderer = SoftwareRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         true /* use_image_hijack_canvas */);
@@ skipping 12 matching lines @@
   aggregator_.reset(new SurfaceAggregator(
       surface_manager_, resource_provider_.get(), output_partial_list));
   aggregator_->set_output_is_secure(output_is_secure_);
 }
 
 void Display::DidLoseOutputSurface() {
   if (scheduler_)
     scheduler_->OutputSurfaceLost();
   // WARNING: The client may delete the Display in this method call. Do not
   // make any additional references to members after this call.
-  client_->OutputSurfaceLost();
+  client_->DisplayOutputSurfaceLost();
 }
 
 void Display::UpdateRootSurfaceResourcesLocked() {
   Surface* surface = surface_manager_->GetSurfaceForId(current_surface_id_);
   bool root_surface_resources_locked = !surface || !surface->GetEligibleFrame();
   if (scheduler_)
     scheduler_->SetRootSurfaceResourcesLocked(root_surface_resources_locked);
 }
 
 bool Display::DrawAndSwap() {
@@ skipping 123 matching lines @@
   // BrowserCompositorOutputSurface that corresponds to vsync.  The BFS is
   // passed BrowserCompositorOutputSurface -> Display -> DisplayScheduler as an
   // input.  DisplayScheduler makes a decision about which BFS to use and
   // calls back to Display as DisplaySchedulerClient to register for that
   // surface id.
   DCHECK(!vsync_begin_frame_source_);
   vsync_begin_frame_source_ = source;
 }
 
 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
-  client_->SetMemoryPolicy(policy);
+  client_->DisplaySetMemoryPolicy(policy);
 }
 
 void Display::OnDraw(const gfx::Transform& transform,
                      const gfx::Rect& viewport,
                      const gfx::Rect& clip,
                      bool resourceless_software_draw) {
   NOTREACHED();
 }
 
 void Display::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
@@ skipping 43 matching lines @@
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc