sync compositor: Remove begin frame source

content/browser/android/synchronous_compositor_host.cc

 // Copyright 2015 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/android/synchronous_compositor_host.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
@@ skipping 53 matching lines @@
     RenderWidgetHostViewAndroid* rwhva,
     SynchronousCompositorClient* client,
     bool use_in_proc_software_draw)
     : rwhva_(rwhva),
       client_(client),
       ui_task_runner_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
       routing_id_(rwhva_->GetRenderWidgetHost()->GetRoutingID()),
       sender_(rwhva_->GetRenderWidgetHost()),
       use_in_process_zero_copy_software_draw_(use_in_proc_software_draw),
-      is_active_(false),
       bytes_limit_(0u),
       renderer_param_version_(0u),
       need_animate_scroll_(false),
       need_invalidate_count_(0u),
-      need_begin_frame_(false),
-      did_activate_pending_tree_count_(0u),
-      weak_ptr_factory_(this) {
+      did_activate_pending_tree_count_(0u) {
   client_->DidInitializeCompositor(this);
 }
 
 SynchronousCompositorHost::~SynchronousCompositorHost() {
   client_->DidDestroyCompositor(this);
-  if (weak_ptr_factory_.HasWeakPtrs())
-    UpdateStateTask();
 }
 
 bool SynchronousCompositorHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorHost, message)
     IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_OutputSurfaceCreated,
                         OutputSurfaceCreated)
     IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_UpdateState, ProcessCommonParams)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void SynchronousCompositorHost::DidBecomeCurrent() {
   client_->DidBecomeCurrent(this);
 }
 
 SynchronousCompositor::Frame SynchronousCompositorHost::DemandDrawHw(
     const gfx::Size& surface_size,
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   SyncCompositorDemandDrawHwParams params(surface_size, transform, viewport,
                                           clip, viewport_rect_for_tile_priority,
                                           transform_for_tile_priority);
   SynchronousCompositor::Frame frame;
   frame.frame.reset(new cc::CompositorFrame);
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
   if (!sender_->Send(new SyncCompositorMsg_DemandDrawHw(
-          routing_id_, common_browser_params, params, &common_renderer_params,
+          routing_id_, params, &common_renderer_params,
           &frame.output_surface_id, frame.frame.get()))) {
     return SynchronousCompositor::Frame();
   }
   ProcessCommonParams(common_renderer_params);
   if (!frame.frame->delegated_frame_data) {
     // This can happen if compositor did not swap in this draw.
     frame.frame.reset();
   }
   if (frame.frame) {
     UpdateFrameMetaData(frame.frame->metadata);
@@ skipping 18 matching lines @@
     SynchronousCompositorSetSkCanvas(nullptr);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedSetSkCanvas);
 };
 
 }
 
 bool SynchronousCompositorHost::DemandDrawSwInProc(SkCanvas* canvas) {
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
   bool success = false;
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   ScopedSetSkCanvas set_sk_canvas(canvas);
   SyncCompositorDemandDrawSwParams params;  // Unused.
   if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw(
-          routing_id_, common_browser_params, params, &success,
-          &common_renderer_params, frame.get()))) {
+          routing_id_, params, &success, &common_renderer_params,
+          frame.get()))) {
     return false;
   }
   if (!success)
     return false;
   ProcessCommonParams(common_renderer_params);
   UpdateFrameMetaData(frame->metadata);
   return true;
 }
 
 class SynchronousCompositorHost::ScopedSendZeroMemory {
@@ skipping 39 matching lines @@
   size_t stride = info.minRowBytes();
   size_t buffer_size = info.getSafeSize(stride);
   if (!buffer_size)
     return false;  // Overflow.
 
   SetSoftwareDrawSharedMemoryIfNeeded(stride, buffer_size);
   if (!software_draw_shm_)
     return false;
 
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
   bool success = false;
   if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw(
-          routing_id_, common_browser_params, params, &success,
-          &common_renderer_params, frame.get()))) {
+          routing_id_, params, &success, &common_renderer_params,
+          frame.get()))) {
     return false;
   }
   ScopedSendZeroMemory send_zero_memory(this);
   if (!success)
     return false;
 
   ProcessCommonParams(common_renderer_params);
   UpdateFrameMetaData(frame->metadata);
 
   SkBitmap bitmap;
@@ skipping 28 matching lines @@
 
   SyncCompositorSetSharedMemoryParams set_shm_params;
   set_shm_params.buffer_size = buffer_size;
   base::ProcessHandle renderer_process_handle =
       rwhva_->GetRenderWidgetHost()->GetProcess()->GetHandle();
   if (!software_draw_shm->shm.ShareToProcess(renderer_process_handle,
                                              &set_shm_params.shm_handle)) {
     return;
   }
 
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   bool success = false;
   SyncCompositorCommonRendererParams common_renderer_params;
   if (!sender_->Send(new SyncCompositorMsg_SetSharedMemory(
-          routing_id_, common_browser_params, set_shm_params, &success,
-          &common_renderer_params)) ||
+          routing_id_, set_shm_params, &success, &common_renderer_params)) ||
       !success) {
     return;
   }
   software_draw_shm_ = std::move(software_draw_shm);
   ProcessCommonParams(common_renderer_params);
 }
 
 void SynchronousCompositorHost::SendZeroMemory() {
   // No need to check return value.
   sender_->Send(new SyncCompositorMsg_ZeroSharedMemory(routing_id_));
@@ skipping 19 matching lines @@
 
 void SynchronousCompositorHost::DidChangeRootLayerScrollOffset(
     const gfx::ScrollOffset& root_offset) {
   if (root_scroll_offset_ == root_offset)
     return;
   root_scroll_offset_ = root_offset;
   sender_->Send(
       new SyncCompositorMsg_SetScroll(routing_id_, root_scroll_offset_));
 }
 
-void SynchronousCompositorHost::SendAsyncCompositorStateIfNeeded() {
-  if (weak_ptr_factory_.HasWeakPtrs())
-    return;
-
-  ui_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&SynchronousCompositorHost::UpdateStateTask,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-void SynchronousCompositorHost::UpdateStateTask() {
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
-  sender_->Send(
-      new SyncCompositorMsg_UpdateState(routing_id_, common_browser_params));
-  DCHECK(!weak_ptr_factory_.HasWeakPtrs());
-}
-
 void SynchronousCompositorHost::SynchronouslyZoomBy(float zoom_delta,
                                                     const gfx::Point& anchor) {
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
   if (!sender_->Send(new SyncCompositorMsg_ZoomBy(
-          routing_id_, common_browser_params, zoom_delta, anchor,
-          &common_renderer_params))) {
+          routing_id_, zoom_delta, anchor, &common_renderer_params))) {
     return;
   }
   ProcessCommonParams(common_renderer_params);
 }
 
-void SynchronousCompositorHost::SetIsActive(bool is_active) {
-  if (is_active_ == is_active)
-    return;
-  is_active_ = is_active;
-  UpdateNeedsBeginFrames();
-  SendAsyncCompositorStateIfNeeded();
-}
-
 void SynchronousCompositorHost::OnComputeScroll(
     base::TimeTicks animation_time) {
   if (!need_animate_scroll_)
     return;
   need_animate_scroll_ = false;
 
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
   SyncCompositorCommonRendererParams common_renderer_params;
-  sender_->Send(new SyncCompositorMsg_ComputeScroll(
-      routing_id_, common_browser_params, animation_time));
+  sender_->Send(
+      new SyncCompositorMsg_ComputeScroll(routing_id_, animation_time));
 }
 
 void SynchronousCompositorHost::DidOverscroll(
     const DidOverscrollParams& over_scroll_params) {
   client_->DidOverscroll(over_scroll_params.accumulated_overscroll,
                          over_scroll_params.latest_overscroll_delta,
                          over_scroll_params.current_fling_velocity);
 }
 
-void SynchronousCompositorHost::BeginFrame(const cc::BeginFrameArgs& args) {
-  if (!is_active_)
-    return;
-
-  SyncCompositorCommonBrowserParams common_browser_params;
-  PopulateCommonParams(&common_browser_params);
+void SynchronousCompositorHost::DidSendBeginFrame() {
   SyncCompositorCommonRendererParams common_renderer_params;
-  if (!sender_->Send(
-          new SyncCompositorMsg_BeginFrame(routing_id_, common_browser_params,
-                                           args, &common_renderer_params))) {
+  if (!sender_->Send(new SyncCompositorMsg_SynchronizeRendererState(
+          routing_id_, &common_renderer_params))) {
     return;
   }
   ProcessCommonParams(common_renderer_params);
 }
 
 void SynchronousCompositorHost::OutputSurfaceCreated() {
   // New output surface is not aware of state from Browser side. So need to
   // re-send all browser side state here.
   sender_->Send(
       new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit_));
 }
 
-void SynchronousCompositorHost::PopulateCommonParams(
-    SyncCompositorCommonBrowserParams* params) {
-  DCHECK(params);
-  params->begin_frame_source_paused = !is_active_;
-
-  weak_ptr_factory_.InvalidateWeakPtrs();
-}
-
 void SynchronousCompositorHost::ProcessCommonParams(
     const SyncCompositorCommonRendererParams& params) {
   // Ignore if |renderer_param_version_| is newer than |params.version|. This
   // comparison takes into account when the unsigned int wraps.
   if ((renderer_param_version_ - params.version) < 0x80000000) {
     return;
   }
   renderer_param_version_ = params.version;
   need_animate_scroll_ = params.need_animate_scroll;
-  if (need_begin_frame_ != params.need_begin_frame) {
-    need_begin_frame_ = params.need_begin_frame;
-    UpdateNeedsBeginFrames();
-  }
   root_scroll_offset_ = params.total_scroll_offset;
 
   if (need_invalidate_count_ != params.need_invalidate_count) {
     need_invalidate_count_ = params.need_invalidate_count;
     client_->PostInvalidate();
   }
 
   if (did_activate_pending_tree_count_ !=
       params.did_activate_pending_tree_count) {
     did_activate_pending_tree_count_ = params.did_activate_pending_tree_count;
     client_->DidUpdateContent();
   }
 
   // Ensure only valid values from compositor are sent to client.
   // Compositor has page_scale_factor set to 0 before initialization, so check
   // for that case here.
   if (params.page_scale_factor) {
     client_->UpdateRootLayerState(
         gfx::ScrollOffsetToVector2dF(params.total_scroll_offset),
         gfx::ScrollOffsetToVector2dF(params.max_scroll_offset),
         params.scrollable_size, params.page_scale_factor,
         params.min_page_scale_factor, params.max_page_scale_factor);
   }
 }
 
-void SynchronousCompositorHost::UpdateNeedsBeginFrames() {
-  rwhva_->OnSetNeedsBeginFrames(is_active_ && need_begin_frame_);
-}
-
 }  // namespace content