Replicate LayoutTestRuntimeFlags across secondary window renderers.

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 27 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/shell/browser/layout_test/layout_test_bluetooth_chooser_factory.h"
 #include "content/shell/browser/layout_test/layout_test_devtools_frontend.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/shell_content_browser_client.h"
 #include "content/shell/browser/shell_devtools_frontend.h"
+#include "content/shell/common/layout_test/layout_test_messages.h"
 #include "content/shell/common/layout_test/layout_test_switches.h"
 #include "content/shell/common/shell_messages.h"
 #include "content/shell/renderer/layout_test/blink_test_helpers.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace content {
 
 namespace {
 
 const int kTestSVGWindowWidthDip = 480;
@@ skipping 314 matching lines @@
 void BlinkTestController::OpenURL(const GURL& url) {
   if (test_phase_ != DURING_TEST)
     return;
 
   Shell::CreateNewWindow(main_window_->web_contents()->GetBrowserContext(),
                          url,
                          main_window_->web_contents()->GetSiteInstance(),
                          gfx::Size());
 }
 
-void BlinkTestController::TestFinishedInSecondaryRenderer() {
+void BlinkTestController::OnTestFinishedInSecondaryRenderer() {
   RenderViewHost* render_view_host =
       main_window_->web_contents()->GetRenderViewHost();
   render_view_host->Send(
       new ShellViewMsg_NotifyDone(render_view_host->GetRoutingID()));
 }
 
 bool BlinkTestController::IsMainWindow(WebContents* web_contents) const {
   return main_window_ && web_contents == main_window_->web_contents();
 }
 
@@ skipping 46 matching lines @@
 
   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_LayoutTestRuntimeFlagsChanged,
-                        OnLayoutTestRuntimeFlagsChanged)
     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(CalledOnValidThread());
@@ skipping 140 matching lines @@
     params.test_url = test_url_;
     params.enable_pixel_dumping = enable_pixel_dumping_;
     params.allow_external_pages =
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAllowExternalPages);
     params.expected_pixel_hash = expected_pixel_hash_;
     params.initial_size = initial_size_;
 
     if (did_send_initial_test_configuration_) {
       frame->Send(new ShellViewMsg_ReplicateTestConfiguration(
-          frame->GetRoutingID(), params,
-          accumulated_layout_test_runtime_flags_changes_));
+          frame->GetRoutingID(), params));
     } else {
       did_send_initial_test_configuration_ = true;
       frame->Send(
           new ShellViewMsg_SetTestConfiguration(frame->GetRoutingID(), params));
     }
   }
 
   // Is this a previously unknown renderer process?
   if (!render_process_host_observer_.IsObserving(process)) {
     render_process_host_observer_.Add(process);
     all_observed_render_process_hosts_.insert(process);
 
     if (!main_window) {
       frame->Send(
           new ShellViewMsg_SetupSecondaryRenderer(frame->GetRoutingID()));
     }
+
+    process->Send(new LayoutTestMsg_ReplicateLayoutTestRuntimeFlagsChanges(
+        accumulated_layout_test_runtime_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 51 matching lines @@
   printer_->PrintTextBlock(dump);
   printer_->PrintTextFooter();
 }
 
 void BlinkTestController::OnInitiateLayoutDump() {
   pending_layout_dumps_ = main_window_->web_contents()->SendToAllFrames(
       new ShellViewMsg_LayoutDumpRequest(MSG_ROUTING_NONE));
 }
 
 void BlinkTestController::OnLayoutTestRuntimeFlagsChanged(
-    RenderFrameHost* sender,
+    int sender_process_host_id,
     const base::DictionaryValue& changed_layout_test_runtime_flags) {
-  // Stash the changes for future renderers.
+  // Stash the accumulated changes for future, not-yet-created renderers.
   accumulated_layout_test_runtime_flags_changes_.MergeDictionary(
       &changed_layout_test_runtime_flags);
 
-  // Only need to send the propagation message once per renderer process.
-  std::set<int> already_covered_process_ids;
+  // 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;
 
-  // No need to propagate the changes back to the process that originated them.
-  // (propagating them back could also clobber subsequent changes in the
-  // originator).
-  already_covered_process_ids.insert(sender->GetProcess()->GetID());
-
-  // Propagate the changes to all the renderer processes associated with the
-  // main window.
-  for (RenderFrameHost* frame : main_window_->web_contents()->GetAllFrames()) {
-    bool inserted_new_item =
-        already_covered_process_ids.insert(frame->GetProcess()->GetID()).second;
-    if (inserted_new_item) {
-      frame->Send(new ShellViewMsg_ReplicateLayoutTestRuntimeFlagsChanges(
-          frame->GetRoutingID(), changed_layout_test_runtime_flags));
-    }
+    process->Send(new LayoutTestMsg_ReplicateLayoutTestRuntimeFlagsChanges(
+        changed_layout_test_runtime_flags));
   }
 }
 
 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 200 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