Use observer pattern instead of sniffing SwapCompositorFrame IPC

content/browser/devtools/render_frame_devtools_agent_host.cc

 // Copyright (c) 2012 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/devtools/render_frame_devtools_agent_host.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/guid.h"
@@ skipping 842 matching lines @@
       if (session()) {
         protocol::InspectorHandler::FromSession(session())
             ->TargetDetached("Render process gone.");
       }
       break;
   }
   DCHECK(CheckConsistency());
 }
 
 bool RenderFrameDevToolsAgentHost::OnMessageReceived(
-    const IPC::Message& message) {
-  if (!current_)
-    return false;
-  if (message.type() == ViewHostMsg_SwapCompositorFrame::ID)
-    OnSwapCompositorFrame(message);
-  return false;
-}
-
-bool RenderFrameDevToolsAgentHost::OnMessageReceived(
     const IPC::Message& message,
     RenderFrameHost* render_frame_host) {
   bool is_current = current_ && current_->host() == render_frame_host;
   bool is_pending = pending_ && pending_->host() == render_frame_host;
   if (!is_current && !is_pending)
     return false;
   if (!IsAttached())
     return false;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(RenderFrameDevToolsAgentHost, message,
@@ skipping 35 matching lines @@
 void RenderFrameDevToolsAgentHost::WasShown() {
   CreatePowerSaveBlocker();
 }
 
 void RenderFrameDevToolsAgentHost::WasHidden() {
 #if defined(OS_ANDROID)
   power_save_blocker_.reset();
 #endif
 }
 
+void RenderFrameDevToolsAgentHost::DidReceiveCompositorFrame() {
+  if (!session())
+    return;
+  const cc::CompositorFrameMetadata& metadata =
+      RenderWidgetHostImpl::From(
+          web_contents()->GetRenderViewHost()->GetWidget())
+          ->last_frame_metadata();
+  protocol::PageHandler* page_handler =
+      protocol::PageHandler::FromSession(session());
+  if (page_handler)
+    page_handler->OnSwapCompositorFrame(metadata.Clone());
+  protocol::InputHandler::FromSession(session())->OnSwapCompositorFrame(
+      metadata);
+  protocol::TracingHandler* tracing_handler =
+      protocol::TracingHandler::FromSession(session());
+  if (frame_trace_recorder_ && tracing_handler->did_initiate_recording()) {
+    frame_trace_recorder_->OnSwapCompositorFrame(
+        current_ ? current_->host() : nullptr, metadata);
+  }
+}
+
 void RenderFrameDevToolsAgentHost::
     DispatchBufferedProtocolMessagesIfNecessary() {
   if (navigating_handles_.empty() &&
       in_navigation_protocol_message_buffer_.size()) {
     DCHECK(current_);
     for (const auto& pair : in_navigation_protocol_message_buffer_) {
       current_->DispatchProtocolMessage(
           pair.second.session_id, pair.first, pair.second.method,
           pair.second.message);
     }
@@ skipping 141 matching lines @@
   }
   return false;
 }
 
 base::TimeTicks RenderFrameDevToolsAgentHost::GetLastActivityTime() {
   if (content::WebContents* contents = web_contents())
     return contents->GetLastActiveTime();
   return base::TimeTicks();
 }
 
-void RenderFrameDevToolsAgentHost::OnSwapCompositorFrame(
-    const IPC::Message& message) {
-  ViewHostMsg_SwapCompositorFrame::Param param;
-  if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
-    return;
-  if (!session())
-    return;
-  protocol::PageHandler* page_handler =
-      protocol::PageHandler::FromSession(session());
-  if (page_handler) {
-    page_handler->OnSwapCompositorFrame(std::move(std::get<2>(param).metadata));
-  }
-  protocol::InputHandler::FromSession(session())->OnSwapCompositorFrame(
-      std::get<2>(param).metadata);
-  protocol::TracingHandler* tracing_handler =
-      protocol::TracingHandler::FromSession(session());
-  if (frame_trace_recorder_ && tracing_handler->did_initiate_recording()) {
-    frame_trace_recorder_->OnSwapCompositorFrame(
-        current_ ? current_->host() : nullptr, std::get<2>(param).metadata);
-  }
-}
-
 void RenderFrameDevToolsAgentHost::SignalSynchronousSwapCompositorFrame(
     RenderFrameHost* frame_host,
     cc::CompositorFrameMetadata frame_metadata) {
   scoped_refptr<RenderFrameDevToolsAgentHost> dtah(FindAgentHost(frame_host));
   if (dtah) {
     // Unblock the compositor.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &RenderFrameDevToolsAgentHost::SynchronousSwapCompositorFrame,
@@ skipping 57 matching lines @@
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
 }  // namespace content