Added message filter receiving frames from compositor

content/browser/android/synchronous_compositor_observer.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 "content/browser/android/synchronous_compositor_observer.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
@@ skipping 12 matching lines @@
 // static
 SynchronousCompositorObserver* SynchronousCompositorObserver::GetOrCreateFor(
     int process_id) {
   auto itr = g_instances.Get().find(process_id);
   if (itr != g_instances.Get().end())
     return itr->second;
   return new SynchronousCompositorObserver(process_id);
 }
 
 SynchronousCompositorObserver::SynchronousCompositorObserver(int process_id)
-    : render_process_host_(RenderProcessHost::FromID(process_id)),
+    : BrowserMessageFilter(SyncCompositorMsgStart),
+      render_process_host_(RenderProcessHost::FromID(process_id)),
       window_android_in_vsync_(nullptr) {
   DCHECK(render_process_host_);
   DCHECK(!base::ContainsKey(g_instances.Get(), render_process_host_->GetID()));
   g_instances.Get()[render_process_host_->GetID()] = this;
   render_process_host_->AddObserver(this);
 }
 
 SynchronousCompositorObserver::~SynchronousCompositorObserver() {
   DCHECK(compositor_host_pending_renderer_state_.empty());
   DCHECK(base::ContainsKey(g_instances.Get(), render_process_host_->GetID()));
@@ skipping 17 matching lines @@
   DCHECK(compositor_host);
   DCHECK(!base::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);
 }
 
+bool SynchronousCompositorObserver::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorObserver, message)
+    IPC_MESSAGE_HANDLER_GENERIC(SyncCompositorHostMsg_ReturnFrame,
+                                ReceiveFrame(message))
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+bool SynchronousCompositorObserver::ReceiveFrame(const IPC::Message& message) {
+  SyncCompositorHostMsg_ReturnFrame::Param param;
+  if (!SyncCompositorHostMsg_ReturnFrame::Read(&message, &param))
+    return false;
+  uint32_t compositor_frame_sink_id = std::get<0>(param);
+  cc::CompositorFrame compositor_frame = std::move(std::get<1>(param));
+
+  content::SynchronousCompositor::Frame frame;
+  frame.frame.reset(new cc::CompositorFrame);
+  frame.compositor_frame_sink_id = compositor_frame_sink_id;
+  *frame.frame = std::move(compositor_frame);
+
+  if (!frame.frame->delegated_frame_data) {
+    frame.frame.reset();
+  }
+
+  std::unique_ptr<SynchronousCompositor::Frame> frame_ptr =
+      base::MakeUnique<SynchronousCompositor::Frame>();
+  frame_ptr->frame = std::move(frame.frame);
+  frame_ptr->compositor_frame_sink_id = frame.compositor_frame_sink_id;
+
+  int routing_id = message.routing_id();
+
+  future_map_[routing_id]->setFrame(std::move(frame_ptr));
+
+  return true;
+}
+
+void SynchronousCompositorObserver::SetFrameFuture(
+    const int routing_id,
+    const scoped_refptr<content::SynchronousCompositor::FrameFuture>&
+        frame_future) {
+  future_map_[routing_id] = std::move(frame_future);
+}
+
 void SynchronousCompositorObserver::OnCompositingDidCommit() {
   NOTREACHED();
 }
 
 void SynchronousCompositorObserver::OnRootWindowVisibilityChanged(
     bool visible) {
   NOTREACHED();
 }
 
 void SynchronousCompositorObserver::OnAttachCompositor() {
@@ skipping 41 matching lines @@
 
 void SynchronousCompositorObserver::OnActivityStopped() {
   NOTREACHED();
 }
 
 void SynchronousCompositorObserver::OnActivityStarted() {
   NOTREACHED();
 }
 
 }  // namespace content