Factor draw functionality out of DefaultPlatformDisplay into FrameGenerator.

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/ipc/quads.mojom.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/surfaces/display_compositor.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/platform_display_factory.h"
+#include "components/mus/ws/platform_display_init_params.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 "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/base/cursor/cursor_loader.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/platform_window/platform_ime_controller.h"
 #include "ui/platform_window/platform_window.h"
 
 #if defined(OS_WIN)
 #include "ui/platform_window/win/win_window.h"
 #elif defined(USE_X11)
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #elif defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace mus {
 
 namespace ws {
-namespace {
-
-// DrawWindowTree recursively visits ServerWindows, creating a SurfaceDrawQuad
-// for each that lacks one.
-void DrawWindowTree(cc::RenderPass* pass,
-                    ServerWindow* window,
-                    const gfx::Vector2d& parent_to_root_origin_offset,
-                    float opacity) {
-  if (!window->visible())
-    return;
-
-  ServerWindowSurface* default_surface =
-      window->surface_manager() ? window->surface_manager()->GetDefaultSurface()
-                                : nullptr;
-
-  const gfx::Rect absolute_bounds =
-      window->bounds() + parent_to_root_origin_offset;
-  std::vector<ServerWindow*> children(window->GetChildren());
-  // TODO(rjkroege, fsamuel): Make sure we're handling alpha correctly.
-  const float combined_opacity = opacity * window->opacity();
-  for (auto it = children.rbegin(); it != children.rend(); ++it) {
-    DrawWindowTree(pass, *it, absolute_bounds.OffsetFromOrigin(),
-                   combined_opacity);
-  }
-
-  if (!window->surface_manager() || !window->surface_manager()->ShouldDraw())
-    return;
-
-  ServerWindowSurface* underlay_surface =
-      window->surface_manager()->GetUnderlaySurface();
-  if (!default_surface && !underlay_surface)
-    return;
-
-  if (default_surface) {
-    gfx::Transform quad_to_target_transform;
-    quad_to_target_transform.Translate(absolute_bounds.x(),
-                                       absolute_bounds.y());
-
-    cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
-
-    const gfx::Rect bounds_at_origin(window->bounds().size());
-    // TODO(fsamuel): These clipping and visible rects are incorrect. They need
-    // to be populated from CompositorFrame structs.
-    sqs->SetAll(quad_to_target_transform,
-                bounds_at_origin.size() /* layer_bounds */,
-                bounds_at_origin /* visible_layer_bounds */,
-                bounds_at_origin /* clip_rect */, false /* is_clipped */,
-                window->opacity(), SkXfermode::kSrcOver_Mode,
-                0 /* sorting-context_id */);
-    auto quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
-    quad->SetAll(sqs, bounds_at_origin /* rect */,
-                 gfx::Rect() /* opaque_rect */,
-                 bounds_at_origin /* visible_rect */, true /* needs_blending*/,
-                 default_surface->id());
-  }
-  if (underlay_surface) {
-    const gfx::Rect underlay_absolute_bounds =
-        absolute_bounds - window->underlay_offset();
-    gfx::Transform quad_to_target_transform;
-    quad_to_target_transform.Translate(underlay_absolute_bounds.x(),
-                                       underlay_absolute_bounds.y());
-    cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
-    const gfx::Rect bounds_at_origin(
-        underlay_surface->last_submitted_frame_size());
-    sqs->SetAll(quad_to_target_transform,
-                bounds_at_origin.size() /* layer_bounds */,
-                bounds_at_origin /* visible_layer_bounds */,
-                bounds_at_origin /* clip_rect */, false /* is_clipped */,
-                window->opacity(), SkXfermode::kSrcOver_Mode,
-                0 /* sorting-context_id */);
-
-    auto quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
-    quad->SetAll(sqs, bounds_at_origin /* rect */,
-                 gfx::Rect() /* opaque_rect */,
-                 bounds_at_origin /* visible_rect */, true /* needs_blending*/,
-                 underlay_surface->id());
-  }
-}
-
-}  // namespace
 
 // static
 PlatformDisplayFactory* PlatformDisplay::factory_ = nullptr;
 
 // static
 PlatformDisplay* PlatformDisplay::Create(
     const PlatformDisplayInitParams& init_params) {
   if (factory_)
     return factory_->CreatePlatformDisplay();
 
   return new DefaultPlatformDisplay(init_params);
 }
 
 DefaultPlatformDisplay::DefaultPlatformDisplay(
     const PlatformDisplayInitParams& init_params)
     : display_id_(init_params.display_id),
-      gpu_state_(init_params.gpu_state),
-      surfaces_state_(init_params.surfaces_state),
-      delegate_(nullptr),
-      draw_timer_(false, false),
-      frame_pending_(false),
 #if !defined(OS_ANDROID)
       cursor_loader_(ui::CursorLoader::Create()),
 #endif
-      weak_factory_(this) {
+      frame_generator_(new FrameGenerator(this,
+                                          init_params.gpu_state,
+                                          init_params.surfaces_state)) {
   metrics_.size_in_pixels = init_params.display_bounds.size();
   // TODO(rjkroege): Preserve the display_id when Ozone platform can use it.
 }
 
 void DefaultPlatformDisplay::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
   gfx::Rect bounds(metrics_.size_in_pixels);
 #if defined(OS_WIN)
   platform_window_.reset(new ui::WinWindow(this, bounds));
 #elif defined(USE_X11)
   platform_window_.reset(new ui::X11Window(this));
 #elif defined(OS_ANDROID)
   platform_window_.reset(new ui::PlatformWindowAndroid(this));
 #elif defined(USE_OZONE)
   platform_window_ =
       ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
 #else
   NOTREACHED() << "Unsupported platform";
 #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 |display_compositor_|.
-  weak_factory_.InvalidateWeakPtrs();
-  display_compositor_.reset();
+  frame_generator_.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())
     return;
   const gfx::Rect root_relative_rect =
       ConvertRectBetweenWindows(window, delegate_->GetRootWindow(), bounds);
   if (root_relative_rect.IsEmpty())
     return;
-  dirty_rect_.Union(root_relative_rect);
-  WantToDraw();
+  frame_generator_->RequestRedraw(root_relative_rect);
 }
 
 void DefaultPlatformDisplay::SetViewportSize(const gfx::Size& size) {
   platform_window_->SetBounds(gfx::Rect(size));
 }
 
 void DefaultPlatformDisplay::SetTitle(const base::string16& title) {
   platform_window_->SetTitle(title);
 }
 
@@ skipping 33 matching lines @@
   if (ime)
     ime->UpdateTextInputState(state);
 }
 
 void DefaultPlatformDisplay::SetImeVisibility(bool visible) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     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 (display_compositor_) {
-    display_compositor_->SubmitCompositorFrame(
-        std::move(frame), base::Bind(&DefaultPlatformDisplay::DidDraw,
-                                     weak_factory_.GetWeakPtr()));
-  }
-  dirty_rect_ = gfx::Rect();
-}
-
-void DefaultPlatformDisplay::DidDraw(cc::SurfaceDrawStatus status) {
-  frame_pending_ = false;
-  delegate_->OnCompositorFrameDrawn();
-  if (!dirty_rect_.IsEmpty())
-    WantToDraw();
-}
-
 bool DefaultPlatformDisplay::IsFramePending() const {
-  return frame_pending_;
+  return frame_generator_->is_frame_pending();
 }
 
 int64_t DefaultPlatformDisplay::GetDisplayId() const {
   return display_id_;
 }
 
-void DefaultPlatformDisplay::WantToDraw() {
-  if (draw_timer_.IsRunning() || frame_pending_)
-    return;
-
-  // TODO(rjkroege): Use vblank to kick off Draw.
-  draw_timer_.Start(
-      FROM_HERE, base::TimeDelta(),
-      base::Bind(&DefaultPlatformDisplay::Draw, weak_factory_.GetWeakPtr()));
-}
-
 void DefaultPlatformDisplay::UpdateMetrics(const gfx::Size& size,
                                            float device_scale_factor) {
   if (display::Display::HasForceDeviceScaleFactor())
     device_scale_factor = display::Display::GetForcedDeviceScaleFactor();
   if (metrics_.size_in_pixels == size &&
       metrics_.device_scale_factor == device_scale_factor)
     return;
 
   ViewportMetrics old_metrics = metrics_;
   metrics_.size_in_pixels = size;
   metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
-std::unique_ptr<cc::CompositorFrame>
-DefaultPlatformDisplay::GenerateCompositorFrame() {
-  std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
-  render_pass->damage_rect = dirty_rect_;
-  render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels);
-
-  DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
-                 1.0f);
-
-  std::unique_ptr<cc::DelegatedFrameData> frame_data(
-      new cc::DelegatedFrameData);
-  frame_data->device_scale_factor = metrics_.device_scale_factor;
-  frame_data->render_pass_list.push_back(std::move(render_pass));
-
-  std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  frame->delegated_frame_data = std::move(frame_data);
-  return frame;
-}
-
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
   UpdateMetrics(new_bounds.size(), metrics_.device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
-  dirty_rect_.Union(damaged_region);
-  WantToDraw();
+  frame_generator_->RequestRedraw(damaged_region);
 }
 
 void DefaultPlatformDisplay::DispatchEvent(ui::Event* event) {
   if (event->IsScrollEvent()) {
     // TODO(moshayedi): crbug.com/602859. Dispatch scroll events as
     // they are once we have proper support for scroll events.
     delegate_->OnEvent(ui::MouseWheelEvent(*event->AsScrollEvent()));
   } else if (event->IsMouseEvent() && !event->IsMouseWheelEvent()) {
     delegate_->OnEvent(ui::PointerEvent(*event->AsMouseEvent()));
   } else if (event->IsTouchEvent()) {
@@ skipping 39 matching lines @@
 void DefaultPlatformDisplay::OnWindowStateChanged(
     ui::PlatformWindowState new_state) {}
 
 void DefaultPlatformDisplay::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_scale_factor) {
-  if (widget != gfx::kNullAcceleratedWidget) {
-    display_compositor_.reset(
-        new DisplayCompositor(base::ThreadTaskRunnerHandle::Get(), widget,
-                              gpu_state_, surfaces_state_));
-  }
+  frame_generator_->OnAcceleratedWidgetAvailable(widget);

[sky, 2016/06/30 23:40:20]

Could we delay creation of frame_generator until we get a valid widget? That
would seem to avoid allowing FrameGenerator to be in a weird state.

[mfomitchev, 2016/07/06 15:53:09]

That would mean that we'd need to add gpu_state and surfaces_state fields to the
PlatformDisplay class (so that we can pass them to FrameGenerator's constructor
in OnAcceleratedWidgetAvailable()), which seems a bit unfortunate. Also, while
we'd remove two checks for display_compositor_ in FrameGenerator, we'd need to
add four checks for frame_generator_ in DefaultPlatformDisplay. So I am not sure
we'd be simplifying the code, but I might be overlooking something, so if you
still think we should do it - let me know, and I will make the change.

   UpdateMetrics(metrics_.size_in_pixels, device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
-  if (display_compositor_)
-    display_compositor_->RequestCopyOfOutput(std::move(output_request));
+  frame_generator_->RequestCopyOfOutput(std::move(output_request));
+}
+
+ServerWindow* DefaultPlatformDisplay::GetRootWindow() {
+  return delegate_->GetRootWindow();
+}
+
+void DefaultPlatformDisplay::OnCompositorFrameDrawn() {
+  if (delegate_)
+    delegate_->OnCompositorFrameDrawn();
+}
+
+const ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics() {
+  return metrics_;
 }
 
 }  // namespace ws
 
 }  // namespace mus