Mojo-ify ShellViewHostMsg_LayoutDumpResponse.

content/shell/browser/layout_test/blink_test_controller.cc

 // Copyright 2013 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/shell/browser/layout_test/blink_test_controller.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <set>
@@ skipping 508 matching lines @@
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_GetBluetoothManualChooserEvents,
                         OnGetBluetoothManualChooserEvents)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_SendBluetoothManualChooserEvent,
                         OnSendBluetoothManualChooserEvent)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-bool BlinkTestController::OnMessageReceived(
-    const IPC::Message& message,
-    RenderFrameHost* render_frame_host) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(BlinkTestController, message,
-                                   render_frame_host)
-    IPC_MESSAGE_HANDLER(ShellViewHostMsg_LayoutDumpResponse,
-                        OnLayoutDumpResponse)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
 void BlinkTestController::PluginCrashed(const base::FilePath& plugin_path,
                                         base::ProcessId plugin_pid) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   printer_->AddErrorMessage(
       base::StringPrintf("#CRASHED - plugin (pid %d)", plugin_pid));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&BlinkTestController::DiscardMainWindow),
                  base::Unretained(this)));
 }
@@ skipping 232 matching lines @@
   printer_->PrintTextFooter();
 }
 
 void BlinkTestController::OnInitiateLayoutDump() {
   int number_of_messages = 0;
   for (RenderFrameHost* rfh : main_window_->web_contents()->GetAllFrames()) {
     if (!rfh->IsRenderFrameLive())
       continue;
 
     ++number_of_messages;
-    GetLayoutTestControlPtr(rfh)->LayoutDumpRequest();
+    GetLayoutTestControlPtr(rfh)->DumpFrameLayout(
+        base::Bind(&BlinkTestController::OnDumpFrameLayoutResponse,
+                   base::Unretained(this), rfh->GetFrameTreeNodeId()));
   }
 
   pending_layout_dumps_ = number_of_messages;
 }
 
 void BlinkTestController::OnLayoutTestRuntimeFlagsChanged(
     int sender_process_host_id,
     const base::DictionaryValue& changed_layout_test_runtime_flags) {
   // Stash the accumulated changes for future, not-yet-created renderers.
   accumulated_layout_test_runtime_flags_changes_.MergeDictionary(
       &changed_layout_test_runtime_flags);
 
   // Propagate the changes to all the tracked renderer processes.
   for (RenderProcessHost* process : all_observed_render_process_hosts_) {
     // Do not propagate the changes back to the process that originated them.
     // (propagating them back could also clobber subsequent changes in the
     // originator).
     if (process->GetID() == sender_process_host_id)
       continue;
 
     process->Send(new LayoutTestMsg_ReplicateLayoutTestRuntimeFlagsChanges(
         changed_layout_test_runtime_flags));
   }
 }
 
-void BlinkTestController::OnLayoutDumpResponse(RenderFrameHost* sender,
-                                               const std::string& dump) {
+void BlinkTestController::OnDumpFrameLayoutResponse(int frame_tree_node_id,
+                                                    const std::string& dump) {
   // Store the result.
   auto pair = frame_to_layout_dump_map_.insert(
-      std::make_pair(sender->GetFrameTreeNodeId(), dump));
+      std::make_pair(frame_tree_node_id, dump));
   bool insertion_took_place = pair.second;
   DCHECK(insertion_took_place);
 
   // See if we need to wait for more responses.
   pending_layout_dumps_--;
   DCHECK_LE(0, pending_layout_dumps_);
   if (pending_layout_dumps_ > 0)
     return;
 
   // Stitch the frame-specific results in the right order.
@@ skipping 221 matching lines @@
   }
   DCHECK(layout_test_control_map_[frame].get());
   return layout_test_control_map_[frame].get();
 }
 
 void BlinkTestController::HandleLayoutTestControlError(RenderFrameHost* frame) {
   layout_test_control_map_.erase(frame);
 }
 
 }  // namespace content