Android Webview IPC-based sync compositing

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 "base/containers/hash_tables.h"
+#include "cc/output/compositor_frame_ack.h"
+#include "content/browser/renderer_host/render_widget_host_view_android.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/android/sync_compositor_messages.h"
+#include "content/public/browser/android/synchronous_compositor_client.h"
+#include "content/public/browser/render_view_host.h"
+#include "ipc/ipc_sender.h"
+
+namespace content {
+
+SynchronousCompositorHost::SynchronousCompositorHost(
+    RenderWidgetHostViewAndroid* rwhva,
+    SynchronousCompositorClient* client)
+    : rwhva_(rwhva),
+      client_(client),
+      routing_id_(rwhva_->GetRenderWidgetHost()->GetRoutingID()),
+      sender_(rwhva_->GetRenderWidgetHost()),
+      is_active_(false),
+      bytes_limit_(0u),
+      renderer_param_version_(0u),
+      need_animate_scroll_(false),
+      need_invalidate_(false),
+      need_begin_frame_(false),
+      did_activate_pending_tree_(false) {
+  client_->DidInitializeCompositor(this);
+}
+
+SynchronousCompositorHost::~SynchronousCompositorHost() {
+  client_->DidDestroyCompositor(this);
+}
+
+bool SynchronousCompositorHost::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorHost, message)
+    IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_UpdateState, ProcessCommonParams)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+scoped_ptr<cc::CompositorFrame> SynchronousCompositorHost::DemandDrawHw(
+    gfx::Size surface_size,
+    const gfx::Transform& transform,
+    gfx::Rect viewport,
+    gfx::Rect clip,
+    gfx::Rect viewport_rect_for_tile_priority,
+    const gfx::Transform& transform_for_tile_priority) {
+  DemandDrawHwParams params(surface_size, transform, viewport, clip,
+                            viewport_rect_for_tile_priority,
+                            transform_for_tile_priority);
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  CommonRendererParams common_renderer_params;
+  if (!sender_->Send(new SyncCompositorMsg_DemandDrawHw(
+      routing_id_, ConstructCommonParams(), params, &common_renderer_params,
+      frame.get()))) {
+    return nullptr;
+  }
+  ProcessCommonParams(common_renderer_params);
+  // TODO(boliu): move this to BVR
+  if (!frame->delegated_frame_data.get()) {

[dcheng, 2015/10/27 21:06:58]

No .get()

[boliu, 2015/10/28 02:07:06]

Done.

+    frame.reset();
+  }
+  if (frame.get())

[dcheng, 2015/10/27 21:06:58]

Ditto, no .get()

[boliu, 2015/10/28 02:07:06]

Done.

+    UpdateFrameMetaData(frame->metadata);
+  return frame.Pass();

[dcheng, 2015/10/27 21:06:58]

return frame; should work

[boliu, 2015/10/28 02:07:06]

Done.

+}
+
+void SynchronousCompositorHost::UpdateFrameMetaData(
+    const cc::CompositorFrameMetadata& frame_metadata) {
+  rwhva_->SynchronousFrameMetadata(frame_metadata);
+}
+
+bool SynchronousCompositorHost::DemandDrawSw(SkCanvas* canvas) {
+  return false;
+}
+
+void SynchronousCompositorHost::ReturnResources(
+    const cc::CompositorFrameAck& frame_ack) {
+  returned_resources_.insert(returned_resources_.end(),
+                             frame_ack.resources.begin(),
+                             frame_ack.resources.end());
+}
+
+void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) {
+  if (bytes_limit_ == bytes_limit)
+    return;
+  bytes_limit_ = bytes_limit;
+  // TODO(boliu): Handle not in draw?
+}
+
+void SynchronousCompositorHost::DidChangeRootLayerScrollOffset(
+    const gfx::ScrollOffset& root_offset) {
+  if (root_scroll_offset_ == root_offset)
+    return;
+  root_scroll_offset_ = root_offset;
+  // TODO(boliu): Handle async.
+}
+
+void SynchronousCompositorHost::SetIsActive(bool is_active) {
+  is_active_ = is_active;
+  UpdateNeedsBeginFrames();
+}
+
+void SynchronousCompositorHost::OnComputeScroll(
+    base::TimeTicks animation_time) {
+  if (!need_animate_scroll_)
+    return;
+  need_animate_scroll_ = false;
+
+  CommonRendererParams common_renderer_params;
+  if (!sender_->Send(new SyncCompositorMsg_ComputeScroll(
+          routing_id_, ConstructCommonParams(), animation_time,
+          &common_renderer_params))) {
+    return;
+  }
+  ProcessCommonParams(common_renderer_params);
+}
+
+InputEventAckState SynchronousCompositorHost::HandleInputEvent(
+    const blink::WebInputEvent& input_event) {
+  CommonRendererParams common_renderer_params;
+  InputEventAckState ack = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  if (!sender_->Send(new SyncCompositorMsg_HandleInputEvent(
+          routing_id_, ConstructCommonParams(), &input_event,
+          &common_renderer_params, &ack))) {
+    return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  }
+  ProcessCommonParams(common_renderer_params);
+  return ack;
+}
+
+void SynchronousCompositorHost::BeginFrame(const cc::BeginFrameArgs& args) {
+  if (!is_active_ || !need_begin_frame_)
+    return;
+
+  CommonRendererParams common_renderer_params;
+  if (!sender_->Send(
+          new SyncCompositorMsg_BeginFrame(routing_id_, ConstructCommonParams(),
+                                           args, &common_renderer_params))) {
+    return;
+  }
+  ProcessCommonParams(common_renderer_params);
+}
+
+CommonBrowserParams SynchronousCompositorHost::ConstructCommonParams() {
+  CommonBrowserParams params(bytes_limit_, root_scroll_offset_);
+  params.resources.swap(returned_resources_);
+  DCHECK(returned_resources_.empty());
+  return params;
+}
+
+void SynchronousCompositorHost::ProcessCommonParams(
+    const CommonRendererParams& params) {
+  if ((renderer_param_version_ - params.version) < 0x80000000) {

[dcheng, 2015/10/27 21:06:58]

What's the significance of 0x80000000? I think this needs a comment.

[boliu, 2015/10/28 02:07:06]

It's for comparing versions when the version can wrap around int. 0x80000000 is
the "mid point" o the resulting difference I guess. I stole this from
https://code.google.com/p/chromium/codesearch#chromium/src/gpu/command_buffer...

Added a comment

+    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();
+  }
+  need_invalidate_ = need_invalidate_ || params.need_invalidate;
+  did_activate_pending_tree_ =
+      did_activate_pending_tree_ || params.did_activate_pending_tree;
+  root_scroll_offset_ = params.total_scroll_offset;
+
+  if (!client_)
+    return;
+  if (need_invalidate_) {
+    need_invalidate_ = false;
+    client_->PostInvalidate();
+  }
+
+  if (did_activate_pending_tree_) {
+    did_activate_pending_tree_ = false;
+    client_->DidUpdateContent();
+  }
+
+  // Make sure renderer side is initialized.
+  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