sync compositor: Reduce begin frame sync IPC overhead

content/browser/android/synchronous_compositor_rph_observer.cc

Index: content/browser/android/synchronous_compositor_rph_observer.cc
diff --git a/content/browser/android/synchronous_compositor_rph_observer.cc b/content/browser/android/synchronous_compositor_rph_observer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9372b2a1b4d445eed6d795cd49dc263eca8ee07b
--- /dev/null
+++ b/content/browser/android/synchronous_compositor_rph_observer.cc
@@ -0,0 +1,133 @@
+// 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 "content/browser/android/synchronous_compositor_rph_observer.h"
+
+#include <map>
+
+#include "base/lazy_instance.h"
+#include "base/stl_util.h"
+#include "content/browser/android/synchronous_compositor_host.h"
+#include "content/browser/bad_message.h"
+#include "content/common/android/sync_compositor_messages.h"
+#include "content/public/browser/render_process_host.h"
+#include "ui/android/window_android.h"
+
+namespace content {
+
+namespace {
+base::LazyInstance<std::map<int, SynchronousCompositorRPHObserver*>>
+    g_instances;
+}
+
+// static
+SynchronousCompositorRPHObserver*
+SynchronousCompositorRPHObserver::GetOrCreateFor(int process_id) {
+  auto itr = g_instances.Get().find(process_id);
+  if (itr != g_instances.Get().end())
+    return itr->second;
+  return new SynchronousCompositorRPHObserver(process_id);
+}
+
+SynchronousCompositorRPHObserver::SynchronousCompositorRPHObserver(
+    int process_id)
+    : render_process_host_(RenderProcessHost::FromID(process_id)),
+      window_android_in_vsync_(nullptr) {
+  DCHECK(render_process_host_);
+  DCHECK(!ContainsKey(g_instances.Get(), render_process_host_->GetID()));
+  g_instances.Get()[render_process_host_->GetID()] = this;
+  render_process_host_->AddObserver(this);
+}
+
+SynchronousCompositorRPHObserver::~SynchronousCompositorRPHObserver() {
+  DCHECK(compositor_host_pending_renderer_state_.empty());
+  DCHECK(ContainsKey(g_instances.Get(), render_process_host_->GetID()));
+  DCHECK_EQ(this, g_instances.Get()[render_process_host_->GetID()]);
+  render_process_host_->RemoveObserver(this);
+  g_instances.Get().erase(render_process_host_->GetID());
+}
+
+void SynchronousCompositorRPHObserver::RenderProcessHostDestroyed(
+    RenderProcessHost* host) {
+  DCHECK_EQ(render_process_host_, host);
+  delete this;
+}
+
+void SynchronousCompositorRPHObserver::SyncStateAfterVSync(
+    ui::WindowAndroid* window_android,
+    SynchronousCompositorHost* compositor_host) {
+  DCHECK(!window_android_in_vsync_ ||
+         window_android_in_vsync_ == window_android)
+      << !!window_android_in_vsync_;
+  DCHECK(compositor_host);
+  DCHECK(
+      !ContainsValue(compositor_host_pending_renderer_state_, compositor_host));
+  compositor_host_pending_renderer_state_.push_back(compositor_host);
+  if (window_android_in_vsync_)
+    return;
+  window_android_in_vsync_ = window_android;
+  window_android_in_vsync_->AddObserver(this);
+}
+
+void SynchronousCompositorRPHObserver::OnCompositingDidCommit() {
+  NOTREACHED();
+}
+
+void SynchronousCompositorRPHObserver::OnRootWindowVisibilityChanged(
+    bool visible) {
+  NOTREACHED();
+}
+
+void SynchronousCompositorRPHObserver::OnAttachCompositor() {
+  NOTREACHED();
+}
+
+void SynchronousCompositorRPHObserver::OnDetachCompositor() {
+  NOTREACHED();
+}
+
+void SynchronousCompositorRPHObserver::OnVSync(base::TimeTicks frame_time,
+                                               base::TimeDelta vsync_period) {
+  // This is called after DidSendBeginFrame for SynchronousCompositorHosts
+  // belonging to this WindowAndroid, since this is added as an Observer after
+  // the observer iteration has started.
+  DCHECK(window_android_in_vsync_);
+  window_android_in_vsync_->RemoveObserver(this);
+  window_android_in_vsync_ = nullptr;
+
+  std::vector<int> routing_ids;
+  routing_ids.reserve(compositor_host_pending_renderer_state_.size());
+  for (const auto host : compositor_host_pending_renderer_state_)
+    routing_ids.push_back(host->routing_id());
+
+  std::vector<SyncCompositorCommonRendererParams> params;
+  params.reserve(compositor_host_pending_renderer_state_.size());
+
+  if (!render_process_host_->Send(
+          new SyncCompositorMsg_SynchronizeRendererState(routing_ids,
+                                                         &params))) {
+    return;
+  }
+
+  if (compositor_host_pending_renderer_state_.size() != params.size()) {
+    bad_message::ReceivedBadMessage(render_process_host_,
+                                    bad_message::SCA_INVALID_ARGUMENT);

[dcheng, 2016/07/22 06:53:44]

I guess a //content reviewer can chime in but wow, there's a lot of
abbreviations on BadMessage...

[no sievers, 2016/07/28 22:03:30]

// The naming convention is abbreviated class
/ name (e.g. RenderFrameHost becomes RFH) plus a unique description of the	 
// reason.

So it should be SCRPHO.

The class name here should probably not have an abbreviation in itself either.
Maybe just SynchronousCompositorObserver? And SCO?

[boliu, 2016/07/28 23:22:40]

both done. at this point, any name is better than the current one.

+    return;
+  }
+
+  for (size_t i = 0; i < compositor_host_pending_renderer_state_.size(); ++i) {
+    compositor_host_pending_renderer_state_[i]->ProcessCommonParams(params[i]);
+  }
+  compositor_host_pending_renderer_state_.clear();
+}
+
+void SynchronousCompositorRPHObserver::OnActivityStopped() {
+  NOTREACHED();
+}
+
+void SynchronousCompositorRPHObserver::OnActivityStarted() {
+  NOTREACHED();
+}
+
+}  // namespace content