Pull parts of TopLevelDisplayClient into DisplayCompositor

components/mus/ws/platform_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 "components/mus/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/public/interfaces/gpu.mojom.h"
 #include "components/mus/public/interfaces/quads.mojom.h"
+#include "components/mus/surfaces/display_compositor.h"
 #include "components/mus/surfaces/surfaces_state.h"
-#include "components/mus/surfaces/top_level_display_client.h"
 #include "components/mus/ws/platform_display_factory.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_surface.h"
 #include "components/mus/ws/server_window_surface_manager.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
@@ skipping 170 matching lines @@
 #endif
   platform_window_->SetBounds(bounds);
   platform_window_->Show();
 }
 
 DefaultPlatformDisplay::~DefaultPlatformDisplay() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   // Invalidate WeakPtrs now to avoid callbacks back into the
-  // DefaultPlatformDisplay during destruction of |top_level_display_client_|.
+  // DefaultPlatformDisplay during destruction of |display_compositor_|.
   weak_factory_.InvalidateWeakPtrs();
-  top_level_display_client_.reset();
+  display_compositor_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
   // first because it can still be using the platform window.
   platform_window_.reset();
 }
 
 void DefaultPlatformDisplay::SchedulePaint(const ServerWindow* window,
                                            const gfx::Rect& bounds) {
   DCHECK(window);
   if (!window->IsDrawn())
@@ skipping 57 matching lines @@
     ime->SetImeVisibility(visible);
 }
 
 void DefaultPlatformDisplay::Draw() {
   if (!delegate_->GetRootWindow()->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
   std::unique_ptr<cc::CompositorFrame> frame(GenerateCompositorFrame());
   frame_pending_ = true;
-  if (top_level_display_client_) {
-    top_level_display_client_->SubmitCompositorFrame(
+  if (display_compositor_) {
+    display_compositor_->SubmitCompositorFrame(
         std::move(frame), base::Bind(&DefaultPlatformDisplay::DidDraw,
                                      weak_factory_.GetWeakPtr()));
   }
   dirty_rect_ = gfx::Rect();
 }
 
-void DefaultPlatformDisplay::DidDraw() {
+void DefaultPlatformDisplay::DidDraw(cc::SurfaceDrawStatus status) {
   frame_pending_ = false;
   delegate_->OnCompositorFrameDrawn();
   if (!dirty_rect_.IsEmpty())
     WantToDraw();
 }
 
 bool DefaultPlatformDisplay::IsFramePending() const {
   return frame_pending_;
 }
 
@@ skipping 104 matching lines @@
     ui::PlatformWindowState new_state) {}
 
 void DefaultPlatformDisplay::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_pixel_ratio) {
   if (widget != gfx::kNullAcceleratedWidget) {
-    top_level_display_client_.reset(
-        new TopLevelDisplayClient(widget, gpu_state_, surfaces_state_));
-    delegate_->OnTopLevelSurfaceChanged(
-        top_level_display_client_->surface_id());
+    display_compositor_.reset(
+        new DisplayCompositor(base::ThreadTaskRunnerHandle::Get(), widget,
+                              gpu_state_, surfaces_state_));
+    delegate_->OnTopLevelSurfaceChanged(display_compositor_->surface_id());
   }
   UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
-  if (top_level_display_client_)
-    top_level_display_client_->RequestCopyOfOutput(std::move(output_request));
+  if (display_compositor_)
+    display_compositor_->RequestCopyOfOutput(std::move(output_request));
 }
 
 }  // namespace ws
 
 }  // namespace mus