Replicate static layout test configuration to all 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 <utility>
@@ skipping 247 matching lines @@
     const GURL& test_url,
     const base::FilePath& current_working_directory,
     bool enable_pixel_dumping,
     const std::string& expected_pixel_hash) {
   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;
+  did_send_initial_test_configuration_ = false;
   printer_->reset();
   frame_to_layout_dump_map_.clear();
+  render_process_host_observer_.RemoveAll();
   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(
         browser_context,
         GURL(),
         NULL,
         initial_size_);
     WebContentsObserver::Observe(main_window_->web_contents());
-    send_configuration_to_next_host_ = true;
     current_pid_ = base::kNullProcessId;
     main_window_->LoadURL(test_url);
   } else {
 #if defined(OS_MACOSX)
     // Shell::SizeTo is not implemented on all platforms.
     main_window_->SizeTo(initial_size_);
 #endif
     main_window_->web_contents()
         ->GetRenderViewHost()
         ->GetWidget()
         ->GetView()
         ->SetSize(initial_size_);
     main_window_->web_contents()
         ->GetRenderViewHost()
         ->GetWidget()
         ->WasResized();
     RenderViewHost* render_view_host =
         main_window_->web_contents()->GetRenderViewHost();
     WebPreferences prefs = render_view_host->GetWebkitPreferences();
     OverrideWebkitPrefs(&prefs);
     render_view_host->UpdateWebkitPreferences(prefs);
-    SendTestConfiguration();
+    HandleNewRenderFrameHost(render_view_host->GetMainFrame());
 
     NavigationController::LoadURLParams params(test_url);
     params.transition_type = ui::PageTransitionFromInt(
         ui::PAGE_TRANSITION_TYPED | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR);
     params.should_clear_history_list = true;
     main_window_->web_contents()->GetController().LoadURLWithParams(params);
     main_window_->web_contents()->Focus();
   }
   main_window_->web_contents()->GetRenderViewHost()->GetWidget()->SetActive(
       true);
   main_window_->web_contents()->GetRenderViewHost()->GetWidget()->Focus();
   return true;
 }
 
 bool BlinkTestController::ResetAfterLayoutTest() {
   DCHECK(CalledOnValidThread());
   printer_->PrintTextFooter();
   printer_->PrintImageFooter();
   printer_->CloseStderr();
-  send_configuration_to_next_host_ = false;
+  did_send_initial_test_configuration_ = false;
   test_phase_ = BETWEEN_TESTS;
   is_compositing_test_ = false;
   enable_pixel_dumping_ = false;
   expected_pixel_hash_.clear();
   test_url_ = GURL();
   prefs_ = WebPreferences();
   should_override_prefs_ = false;
 
 #if defined(OS_ANDROID)
   // Re-using the shell's main window on Android causes issues with networking
@@ skipping 115 matching lines @@
       base::StringPrintf("#CRASHED - plugin (pid %d)", plugin_pid));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&BlinkTestController::DiscardMainWindow),
                  base::Unretained(this)));
 }
 
 void BlinkTestController::RenderFrameCreated(
     RenderFrameHost* render_frame_host) {
   DCHECK(CalledOnValidThread());
-
-  // Monitor the new renderer process for crashes.
-  RenderProcessHost* render_process_host = render_frame_host->GetProcess();
-  if (!render_process_host_observer_.IsObserving(render_process_host))
-    render_process_host_observer_.Add(render_process_host);
-
-  // Ignore hosts created for frames other than the main / top-level frame.
-  if (render_frame_host->GetParent() != nullptr)
-    return;
-
-  // Might be kNullProcessHandle, in which case we will receive a notification
-  // later when the RenderProcessHost was created.
-  base::ProcessHandle handle = render_process_host->GetHandle();
-  if (handle != base::kNullProcessHandle)
-    current_pid_ = base::GetProcId(handle);
-
-  if (!send_configuration_to_next_host_)
-    return;
-  send_configuration_to_next_host_ = false;
-  SendTestConfiguration();
+  HandleNewRenderFrameHost(render_frame_host);
 }
 
 void BlinkTestController::RenderFrameHostChanged(RenderFrameHost* old_host,
                                                  RenderFrameHost* new_host) {
   DCHECK(CalledOnValidThread());
-
-  // Monitor the new renderer process for crashes.
-  RenderProcessHost* render_process_host = new_host->GetProcess();
-  if (!render_process_host_observer_.IsObserving(render_process_host))
-    render_process_host_observer_.Add(render_process_host);
-
-  // Ignore host changes for frames other than the main / top-level frame.
-  if (new_host->GetParent() != nullptr)
-    return;
-
-  base::ProcessHandle process_handle = render_process_host->GetHandle();
-  DCHECK(process_handle != base::kNullProcessHandle);
-  current_pid_ = base::GetProcId(process_handle);
-
-  SendTestConfiguration();
+  HandleNewRenderFrameHost(new_host);
 }
 
 void BlinkTestController::DevToolsProcessCrashed() {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - devtools");
   if (devtools_frontend_)
       devtools_frontend_->Close();
   devtools_frontend_ = NULL;
 }
 
@@ skipping 79 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     test_phase_ = CLEAN_UP;
   } else if (main_window_) {
     main_window_->Close();
   }
   main_window_ = NULL;
   current_pid_ = base::kNullProcessId;
 }
 
-void BlinkTestController::SendTestConfiguration() {
-  RenderViewHost* render_view_host =
-      main_window_->web_contents()->GetRenderViewHost();
+void BlinkTestController::HandleNewRenderFrameHost(RenderFrameHost* frame) {
+  RenderProcessHost* process = frame->GetProcess();
+
+  // Track pid of the renderer handling the main frame.
+  if (frame->GetParent() == nullptr) {
+    base::ProcessHandle process_handle = process->GetHandle();
+    if (process_handle != base::kNullProcessHandle)
+      current_pid_ = base::GetProcId(process_handle);
+  }
+
+  // Does RenderFrameHost map to a RenderFrame in a previously unknown process?
+  if (render_process_host_observer_.IsObserving(process))
+    return;  // No need to do anything more for an already known process.
+  render_process_host_observer_.Add(process);
+
+  // Make sure the new renderer process has a test configuration shared with
+  // other renderers.
   ShellTestConfiguration params;
   params.current_working_directory = current_working_directory_;
   params.temp_path = temp_path_;
   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_;
-  render_view_host->Send(new ShellViewMsg_SetTestConfiguration(
-      render_view_host->GetRoutingID(), params));
+
+  if (did_send_initial_test_configuration_) {
+    frame->Send(new ShellViewMsg_ReplicateTestConfiguration(
+        frame->GetRoutingID(), params));
+  } else {
+    did_send_initial_test_configuration_ = true;
+    frame->Send(
+        new ShellViewMsg_SetTestConfiguration(frame->GetRoutingID(), params));
+  }
 }
 
 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 262 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