ABANDONED CL: Shared-memory-based approach to layout tests runtime flags replication.

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 242 matching lines @@
   DiscardMainWindow();
   instance_ = NULL;
 }
 
 bool BlinkTestController::PrepareForLayoutTest(
     const GURL& test_url,
     const base::FilePath& current_working_directory,
     bool enable_pixel_dumping,
     const std::string& expected_pixel_hash) {
   DCHECK(CalledOnValidThread());
+  VLOG(1) << "Preparing for the next layout test...";
+
+  if (!base::SharedMemory::IsHandleValid(layout_dump_flags_memory_.handle())) {
+    if (!layout_dump_flags_memory_.CreateAnonymous(
+            sizeof(test_runner::LayoutDumpFlags))) {
+      // TODO / DO NOT SUBMIT: Report the error somehow.
+      CHECK(false);
+    }
+  }
+  DCHECK(base::SharedMemory::IsHandleValid(layout_dump_flags_memory_.handle()));
+
   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();
   ShellBrowserContext* browser_context =
@@ skipping 314 matching lines @@
   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_;
+  params.layout_dump_flags_memory_handle =
+      base::SharedMemory::DuplicateHandle(layout_dump_flags_memory_.handle());
 
   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));
   }
 }
 
 void BlinkTestController::OnTestFinished() {
+  VLOG(1) << "Test finished";
+
   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);
 
   ShellBrowserContext* browser_context =
       ShellContentBrowserClient::Get()->browser_context();
   StoragePartition* storage_partition =
@@ skipping 41 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());
-  pending_layout_dumps_ = main_window_->web_contents()->SendToAllFrames(
-      new ShellViewMsg_LayoutDumpRequest(MSG_ROUTING_NONE, layout_dump_flags));
+void BlinkTestController::OnInitiateLayoutDump(bool dump_child_frames) {
+  if (dump_child_frames) {
+    pending_layout_dumps_ = main_window_->web_contents()->SendToAllFrames(
+        new ShellViewMsg_LayoutDumpRequest(MSG_ROUTING_NONE));
+    VLOG(1) << "Asking all " << pending_layout_dumps_
+            << " frames for a layout dump.";
+  } else {
+    VLOG(1) << "Asking the main frame for a layout dump.";
+    RenderFrameHost* main_frame = main_window_->web_contents()->GetMainFrame();
+    main_frame->Send(
+        new ShellViewMsg_LayoutDumpRequest(main_frame->GetRoutingID()));
+    pending_layout_dumps_ = 1;
+  }
 }
 
 void BlinkTestController::OnLayoutDumpResponse(RenderFrameHost* sender,
                                                const std::string& dump) {
+  VLOG(1) << "Got layout dump response from frame "
+          << sender->GetFrameTreeNodeId();
+
   // 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);
 
   // See if we need to wait for more responses.
   pending_layout_dumps_--;
   DCHECK_LE(0, pending_layout_dumps_);
   if (pending_layout_dumps_ > 0)
@@ skipping 114 matching lines @@
   Shell* devtools_shell = devtools_frontend_ ?
       devtools_frontend_->frontend_shell() : NULL;
   for (size_t i = 0; i < open_windows.size(); ++i) {
     if (open_windows[i] != main_window_ && open_windows[i] != devtools_shell)
       open_windows[i]->Close();
   }
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void BlinkTestController::OnResetDone() {
+  VLOG(1) << "Reset done.";
   if (is_leak_detection_enabled_) {
     if (main_window_ && main_window_->web_contents()) {
       RenderViewHost* render_view_host =
           main_window_->web_contents()->GetRenderViewHost();
       render_view_host->Send(
           new ShellViewMsg_TryLeakDetection(render_view_host->GetRoutingID()));
     }
     return;
   }
 
+  VLOG(1) << "Quitting the message loop...";
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void BlinkTestController::OnLeakDetectionDone(
     const LeakDetectionResult& result) {
   if (!result.leaked) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     return;
@@ skipping 45 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