Replicating LayoutDumpFlags across OOPIFs.

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>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 242 matching lines @@
   DCHECK(CalledOnValidThread());
   test_phase_ = DURING_TEST;
   current_working_directory_ = current_working_directory;
   enable_pixel_dumping_ = enable_pixel_dumping;
   expected_pixel_hash_ = expected_pixel_hash;
   test_url_ = test_url;
   need_to_send_test_configuration_to_renderer_ = true;
   printer_->reset();
   frame_to_layout_dump_map_.clear();
   render_process_host_observer_.RemoveAll();
+  accumulated_layout_dump_flags_changes_.Clear();
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
   if (test_url.spec().find("compositing/") != std::string::npos)
     is_compositing_test_ = true;
   initial_size_ = Shell::GetShellDefaultSize();
   // The W3C SVG layout tests use a different size than the other layout tests.
   if (test_url.spec().find("W3C-SVG-1.1") != std::string::npos)
     initial_size_ = gfx::Size(kTestSVGWindowWidthDip, kTestSVGWindowHeightDip);
   if (!main_window_) {
     main_window_ = content::Shell::CreateNewWindow(
@@ skipping 107 matching lines @@
 scoped_ptr<BluetoothChooser> BlinkTestController::RunBluetoothChooser(
     RenderFrameHost* frame,
     const BluetoothChooser::EventHandler& event_handler) {
   if (bluetooth_chooser_factory_) {
     return bluetooth_chooser_factory_->RunBluetoothChooser(frame,
                                                            event_handler);
   }
   return nullptr;
 }
 
 bool BlinkTestController::OnMessageReceived(const IPC::Message& message) {

[jochen (gone - plz use gerrit), 2016/03/04 12:50:37]

just override OnMessageReceived(const IPC::Message& message, RenderFrameHost*
rfh) here instead. Then you know where the message came from.

[Łukasz Anforowicz, 2016/03/04 19:58:56]

Done.

Thanks for pushing in this direction.  I've considered this option, but
initially rejected it because it means sending via an arbitrarily picked local
frame from BlinkTestRunner::OnLayoutDumpFlagsChanged.  OTOH, I've discussed this
with nasko@ and dcheng@ and they think guid-trick is more hacky and also prefer
detecting the sender via WebContentsObserver::OnMessageReceived(...,
RenderFrameHost*) overload.  To some extent this is consistent with the
long-term desire to make all RenderViewObservers (including BlinkTestRunner)
RenderFrameObservers (although I am skeptical when this will be possible for
BlinkTestRunner - test_runner::TestRunner seems to have a lot of things that are
inherently per-view, not per-frame [i.e. ForceRedSelectionColors or
SetPageVisibility or SetMockScreenOrientation]).

Note that I accidentally included some undesirable reverts in Patchset#8  - to
see the intended differences it is probably best to compare Patchset#9 with
Patchset#7.

   DCHECK(CalledOnValidThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BlinkTestController, message)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_PrintMessage, OnPrintMessage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TextDump, OnTextDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_InitiateLayoutDump,
                         OnInitiateLayoutDump)
+    IPC_MESSAGE_HANDLER(ShellViewHostMsg_LayoutDumpFlagsChanged,
+                        OnLayoutDumpFlagsChanged)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ImageDump, OnImageDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_AudioDump, OnAudioDump)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_OverridePreferences,
                         OnOverridePreferences)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_TestFinished, OnTestFinished)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ClearDevToolsLocalStorage,
                         OnClearDevToolsLocalStorage)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_ShowDevTools, OnShowDevTools)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_CloseDevTools, OnCloseDevTools)
     IPC_MESSAGE_HANDLER(ShellViewHostMsg_GoToOffset, OnGoToOffset)
@@ skipping 177 matching lines @@
           switches::kAllowExternalPages);
   params.expected_pixel_hash = expected_pixel_hash_;
   params.initial_size = initial_size_;
 
   if (need_to_send_test_configuration_to_renderer_) {
     need_to_send_test_configuration_to_renderer_ = false;
     frame->Send(
         new ShellViewMsg_SetTestConfiguration(frame->GetRoutingID(), params));
   } else {
     frame->Send(new ShellViewMsg_ReplicateTestConfiguration(
-        frame->GetRoutingID(), params));
+        frame->GetRoutingID(), params, accumulated_layout_dump_flags_changes_));
   }
 }
 
 void BlinkTestController::OnTestFinished() {
   test_phase_ = CLEAN_UP;
   if (!printer_->output_finished())
     printer_->PrintImageFooter();
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   main_window_->web_contents()->ExitFullscreen(/*will_cause_resize=*/false);
@@ skipping 45 matching lines @@
   printer_->PrintAudioBlock(dump);
   printer_->PrintAudioFooter();
 }
 
 void BlinkTestController::OnTextDump(const std::string& dump) {
   printer_->PrintTextHeader();
   printer_->PrintTextBlock(dump);
   printer_->PrintTextFooter();
 }
 
-void BlinkTestController::OnInitiateLayoutDump(
-    const test_runner::LayoutDumpFlags& layout_dump_flags) {
-  DCHECK(layout_dump_flags.dump_child_frames());
+void BlinkTestController::OnInitiateLayoutDump() {
   pending_layout_dumps_ = main_window_->web_contents()->SendToAllFrames(
-      new ShellViewMsg_LayoutDumpRequest(MSG_ROUTING_NONE, layout_dump_flags));
+      new ShellViewMsg_LayoutDumpRequest(MSG_ROUTING_NONE));
+}
+
+void BlinkTestController::OnLayoutDumpFlagsChanged(
+    const base::DictionaryValue& changed_layout_dump_flags,
+    const std::string& change_originator_guid) {
+  accumulated_layout_dump_flags_changes_.MergeDictionary(
+      &changed_layout_dump_flags);
+
+  std::set<int> already_covered_process_ids;
+  for (RenderFrameHost* frame : main_window_->web_contents()->GetAllFrames()) {
+    // TODO(lukasza): Skip original sender of the change notification.
+    // Note - this is not just perf optimization - we also don't want to
+    // clobber changes that might have happened in the original sender
+    // since it sent the notification.
+    bool inserted =
+        already_covered_process_ids.insert(frame->GetProcess()->GetID()).second;
+    if (inserted) {
+      frame->Send(new ShellViewMsg_ReplicateLayoutDumpFlagsChanges(
+          frame->GetRoutingID(), changed_layout_dump_flags,
+          change_originator_guid));
+    }
+  }
 }
 
 void BlinkTestController::OnLayoutDumpResponse(RenderFrameHost* sender,
                                                const std::string& dump) {
   // Store the result.
   auto pair = frame_to_layout_dump_map_.insert(
       std::make_pair(sender->GetFrameTreeNodeId(), dump));
   bool insertion_took_place = pair.second;
   DCHECK(insertion_took_place);
 
@@ skipping 193 matching lines @@
   } else {
     printer_->AddErrorMessage(base::StringPrintf(
         "FAIL: Unexpected sendBluetoothManualChooserEvent() event name '%s'.",
         event_name.c_str()));
     return;
   }
   bluetooth_chooser_factory_->SendEvent(event, argument);
 }
 
 }  // namespace content