Mus+Ash: Unified BeginFrame Skeleton

services/ui/ws/frame_generator.cc

 // Copyright 2016 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 "services/ui/ws/frame_generator.h"
 
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 16 matching lines @@
 FrameGenerator::FrameGenerator(
     FrameGeneratorDelegate* delegate,
     ServerWindow* root_window,
     scoped_refptr<DisplayCompositor> display_compositor)
     : delegate_(delegate),
       display_compositor_(display_compositor),
       frame_sink_id_(
           WindowIdToTransportId(root_window->id()),
           static_cast<uint32_t>(mojom::CompositorFrameSinkType::DEFAULT)),
       root_window_(root_window),
-      draw_timer_(false, false),
       binding_(this),
       weak_factory_(this) {
   DCHECK(delegate_);
   surface_sequence_generator_.set_frame_sink_id(frame_sink_id_);
 }
 
 FrameGenerator::~FrameGenerator() {
   ReleaseAllSurfaceReferences();
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |compositor_frame_sink_|.
   weak_factory_.InvalidateWeakPtrs();
   compositor_frame_sink_.reset();
 }
 
 void FrameGenerator::OnGpuChannelEstablished(
     scoped_refptr<gpu::GpuChannelHost> channel) {
   if (widget_ != gfx::kNullAcceleratedWidget) {
     cc::mojom::MojoCompositorFrameSinkRequest request =
         mojo::GetProxy(&compositor_frame_sink_);
     // TODO(fsamuel): FrameGenerator should not know about
     // SurfacesContextProvider. In fact, FrameGenerator should not know
     // about GpuChannelHost.
     root_window_->CreateCompositorFrameSink(
         mojom::CompositorFrameSinkType::DEFAULT, widget_,
         channel->gpu_memory_buffer_manager(),
         new SurfacesContextProvider(widget_, channel), std::move(request),
         binding_.CreateInterfacePtrAndBind());
+    // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
+    // even when we don't need it. Once surface ID propagation work is done,
+    // this will not be necessary because FrameGenerator will only need a
+    // BeginFrame if the window manager changes.
+    compositor_frame_sink_->SetNeedsBeginFrame(true);
   } else {
     gpu_channel_ = std::move(channel);
   }
 }
 
-void FrameGenerator::RequestRedraw(const gfx::Rect& redraw_region) {
-  dirty_rect_.Union(redraw_region);
-  WantToDraw();
-}
-
 void FrameGenerator::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget) {
   widget_ = widget;
   if (gpu_channel_ && widget != gfx::kNullAcceleratedWidget) {
     cc::mojom::MojoCompositorFrameSinkRequest request =
         mojo::GetProxy(&compositor_frame_sink_);
     root_window_->CreateCompositorFrameSink(
         mojom::CompositorFrameSinkType::DEFAULT, widget_,
         gpu_channel_->gpu_memory_buffer_manager(),
         new SurfacesContextProvider(widget_, std::move(gpu_channel_)),
         std::move(request), binding_.CreateInterfacePtrAndBind());
+    // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
+    // even when we don't need it. Once surface ID propagation work is done,
+    // this will not be necessary because FrameGenerator will only need a
+    // BeginFrame if the window manager changes.
+    compositor_frame_sink_->SetNeedsBeginFrame(true);
   }
 }
 
-void FrameGenerator::DidReceiveCompositorFrameAck() {
-  frame_pending_ = false;
-  if (!dirty_rect_.IsEmpty())
-    WantToDraw();
+void FrameGenerator::DidReceiveCompositorFrameAck() {}
+
+void FrameGenerator::OnBeginFrame(const cc::BeginFrameArgs& begin_frame_arags) {
+  if (!delegate_->GetRootWindow()->visible())
+    return;
+
+  const gfx::Rect output_rect(delegate_->GetViewportMetrics().pixel_size);
+  // TODO(fsamuel): We should add a trace for generating a top level frame.
+  cc::CompositorFrame frame(GenerateCompositorFrame(output_rect));
+  if (compositor_frame_sink_)
+    compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
 }
 
 void FrameGenerator::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   // Nothing to do here because FrameGenerator CompositorFrames don't reference
   // any resources.
 }
 
-void FrameGenerator::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(&FrameGenerator::Draw, weak_factory_.GetWeakPtr()));
-}
-
-void FrameGenerator::Draw() {
-  if (!delegate_->GetRootWindow()->visible())
-    return;
-
-  const gfx::Rect output_rect(delegate_->GetViewportMetrics().pixel_size);
-  dirty_rect_.Intersect(output_rect);
-  // TODO(fsamuel): We should add a trace for generating a top level frame.
-  cc::CompositorFrame frame(GenerateCompositorFrame(output_rect));
-  if (compositor_frame_sink_) {
-    frame_pending_ = true;
-    compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
-  }
-  dirty_rect_ = gfx::Rect();
-}
-
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
     const gfx::Rect& output_rect) {
   const cc::RenderPassId render_pass_id(1, 1);
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
-  render_pass->SetNew(render_pass_id, output_rect, dirty_rect_,
+  render_pass->SetNew(render_pass_id, output_rect, output_rect,
                       gfx::Transform());
 
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f);
 
   cc::CompositorFrame frame;
   frame.render_pass_list.push_back(std::move(render_pass));
   if (delegate_->IsInHighContrastMode()) {
     std::unique_ptr<cc::RenderPass> invert_pass = cc::RenderPass::Create();
-    invert_pass->SetNew(cc::RenderPassId(2, 0), output_rect, dirty_rect_,
+    invert_pass->SetNew(cc::RenderPassId(2, 0), output_rect, output_rect,
                         gfx::Transform());
     cc::SharedQuadState* shared_state =
         invert_pass->CreateAndAppendSharedQuadState();
     shared_state->SetAll(gfx::Transform(), output_rect.size(), output_rect,
                          output_rect, false, 1.f, SkXfermode::kSrcOver_Mode, 0);
     auto* quad = invert_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
     cc::FilterOperations filters;
     filters.Append(cc::FilterOperation::CreateInvertFilter(1.f));
     quad->SetNew(shared_state, output_rect, output_rect, render_pass_id,
                  0 /* mask_resource_id */, gfx::Vector2dF() /* mask_uv_scale */,
@@ skipping 175 matching lines @@
   cc::SurfaceId underlay_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::UNDERLAY);
   if (!underlay_surface_id.is_null())
     ReleaseFrameSinkReference(underlay_surface_id.frame_sink_id());
 }
 
 }  // namespace ws
 
 }  // namespace ui