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

components/test_runner/test_runner.cc

 // Copyright 2014 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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
+#include "components/test_runner/layout_dump_flags.h"
 #include "components/test_runner/mock_credential_manager_client.h"
 #include "components/test_runner/mock_web_speech_recognizer.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/test_preferences.h"
 #include "components/test_runner/web_content_settings.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/test_runner/web_test_proxy.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/handle.h"
@@ skipping 1576 matching lines @@
   Reset();
 }
 
 void TestRunner::WorkQueue::ProcessWorkSoon() {
   if (controller_->topLoadingFrame())
     return;
 
   if (!queue_.empty()) {
     // We delay processing queued work to avoid recursion problems.
     controller_->delegate_->PostTask(new WorkQueueTask(this));
-  } else if (!controller_->wait_until_done_) {
+  } else if (!controller_->layout_dump_flags()->wait_until_done) {
     controller_->delegate_->TestFinished();
   }
 }
 
 void TestRunner::WorkQueue::Reset() {
   frozen_ = false;
   while (!queue_.empty()) {
     delete queue_.front();
     queue_.pop_front();
   }
@@ skipping 11 matching lines @@
   // Quit doing work once a load is in progress.
   while (!queue_.empty()) {
     bool startedLoad = queue_.front()->Run(controller_->delegate_,
                                            controller_->web_view_);
     delete queue_.front();
     queue_.pop_front();
     if (startedLoad)
       return;
   }
 
-  if (!controller_->wait_until_done_ && !controller_->topLoadingFrame())
+  if (!controller_->layout_dump_flags()->wait_until_done &&
+      !controller_->topLoadingFrame())
     controller_->delegate_->TestFinished();
 }
 
 void TestRunner::WorkQueue::WorkQueueTask::RunIfValid() {
   object_->ProcessWork();
 }
 
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
       disable_notify_done_(false),
       web_history_item_count_(0),
       intercept_post_message_(false),
-      layout_dump_flags_(
-          false,  // dump_as_text
-          false,  // dump_child_frames_as_text
-          false,  // dump_as_markup
-          false,  // dump_child_frames_as_markup
-          false,  // dump_child_frame_scroll_positions
-          false),  // is_printing
+      layout_dump_flags_(nullptr),
       test_interfaces_(interfaces),
       delegate_(nullptr),
       web_view_(nullptr),
       web_content_settings_(new WebContentSettings()),
       weak_factory_(this) {}
 
 TestRunner::~TestRunner() {}
 
 void TestRunner::Install(WebFrame* frame) {
   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), frame);
@@ skipping 20 matching lines @@
     web_view_->setSelectionColors(
         0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
 #endif
     web_view_->setVisibilityState(WebPageVisibilityStateVisible, true);
     web_view_->mainFrame()->enableViewSourceMode(false);
 
     web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
   }
 
   top_loading_frame_ = nullptr;
-  wait_until_done_ = false;
+  // TODO / DO NOT SUBMIT - memory fence needed here and in other places :-/.
+  layout_dump_flags()->wait_until_done = false;
+  // TODO / DO NOT SUBMIT - memory fence needed here and in other places :-/.
   wait_until_external_url_load_ = false;
   policy_delegate_enabled_ = false;
   policy_delegate_is_permissive_ = false;
   policy_delegate_should_notify_done_ = false;
 
   WebSecurityPolicy::resetOriginAccessWhitelists();
 #if defined(__linux__) || defined(ANDROID)
   WebFontRendering::setSubpixelPositioning(false);
 #endif
 
   if (delegate_) {
     // Reset the default quota for each origin to 5MB
     delegate_->SetDatabaseQuota(5 * 1024 * 1024);
     delegate_->SetDeviceColorProfile("reset");
     delegate_->SetDeviceScaleFactor(GetDefaultDeviceScaleFactor());
     delegate_->SetAcceptAllCookies(false);
     delegate_->SetLocale("");
     delegate_->UseUnfortunateSynchronousResizeMode(false);
     delegate_->DisableAutoResizeMode(WebSize());
     delegate_->DeleteAllCookies();
     delegate_->ResetScreenOrientation();
     delegate_->SetBluetoothMockDataSet("");
     delegate_->ClearGeofencingMockProvider();
     delegate_->ResetPermissions();
     ResetDeviceLight();
   }
 
   dump_editting_callbacks_ = false;
-  layout_dump_flags_.dump_as_text = false;
-  layout_dump_flags_.dump_as_markup = false;
-  generate_pixel_results_ = true;
-  layout_dump_flags_.dump_child_frame_scroll_positions = false;
-  layout_dump_flags_.dump_child_frames_as_text = false;
-  layout_dump_flags_.dump_child_frames_as_markup = false;
+  layout_dump_flags()->dump_as_text = false;
+  layout_dump_flags()->dump_as_markup = false;
+  layout_dump_flags()->generate_pixel_results = true;
+  layout_dump_flags()->dump_child_frame_scroll_positions = false;
+  layout_dump_flags()->dump_child_frames_as_text = false;
+  layout_dump_flags()->dump_child_frames_as_markup = false;
   dump_icon_changes_ = false;
   dump_as_audio_ = false;
   dump_frame_load_callbacks_ = false;
   dump_ping_loader_callbacks_ = false;
   dump_user_gesture_in_frame_load_callbacks_ = false;
   dump_title_changes_ = false;
   dump_create_view_ = false;
   can_open_windows_ = false;
   dump_resource_load_callbacks_ = false;
   dump_resource_request_callbacks_ = false;
   dump_resource_response_mime_types_ = false;
   dump_window_status_changes_ = false;
   dump_spell_check_callbacks_ = false;
   dump_back_forward_list_ = false;
   dump_selection_rect_ = false;
   dump_drag_image_ = false;
   dump_navigation_policy_ = false;
   test_repaint_ = false;
   sweep_horizontally_ = false;
-  layout_dump_flags_.is_printing = false;
+  layout_dump_flags()->is_printing = false;
   midi_accessor_result_ = true;
   should_stay_on_page_after_handling_before_unload_ = false;
   should_dump_resource_priorities_ = false;
   has_custom_text_output_ = false;
   custom_text_output_.clear();
 
   http_headers_to_clear_.clear();
 
   platform_name_ = "chromium";
   tooltip_text_ = std::string();
@@ skipping 14 matching lines @@
   if (close_remaining_windows_ && delegate_)
     delegate_->CloseRemainingWindows();
   else
     close_remaining_windows_ = true;
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
 }
 
+void TestRunner::SetSharedLayoutDumpFlags(
+    LayoutDumpFlags* shared_layout_dump_flags) {
+  DCHECK(shared_layout_dump_flags);
+  layout_dump_flags_ = shared_layout_dump_flags;
+}
+
 void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
   delegate_->PostTask(task.release());
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return dump_editting_callbacks_;
 }
 
 void TestRunner::setShouldDumpAsText(bool value) {
-  layout_dump_flags_.dump_as_text = value;
+  layout_dump_flags()->dump_as_text = value;
 }
 
 void TestRunner::setShouldDumpAsMarkup(bool value) {
-  layout_dump_flags_.dump_as_markup = value;
+  layout_dump_flags()->dump_as_markup = value;
 }
 
 bool TestRunner::shouldDumpAsCustomText() const {
   return has_custom_text_output_;
 }
 
 std::string TestRunner::customDumpText() const {
   return custom_text_output_;
 }
 
 void TestRunner::setCustomTextOutput(const std::string& text) {
   custom_text_output_ = text;
   has_custom_text_output_ = true;
 }
 
 bool TestRunner::ShouldGeneratePixelResults() {
   CheckResponseMimeType();
-  return generate_pixel_results_;
+  return layout_dump_flags()->generate_pixel_results;
 }
 
 bool TestRunner::ShouldStayOnPageAfterHandlingBeforeUnload() const {
   return should_stay_on_page_after_handling_before_unload_;
 }
 
 
 void TestRunner::setShouldGeneratePixelResults(bool value) {
-  generate_pixel_results_ = value;
+  layout_dump_flags()->generate_pixel_results = value;
 }
 
 bool TestRunner::ShouldDumpAsAudio() const {
   return dump_as_audio_;
 }
 
 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const {
   *buffer_view = audio_data_;
 }
 
 const LayoutDumpFlags& TestRunner::GetLayoutDumpFlags() {
   CheckResponseMimeType();
-  return layout_dump_flags_;
+  return *layout_dump_flags_;
 }
 
 bool TestRunner::HasCustomTextDump(std::string* custom_text_dump) const {
   if (shouldDumpAsCustomText()) {
     *custom_text_dump = customDumpText();
     return true;
   }
 
   return false;
 }
@@ skipping 64 matching lines @@
 
 bool TestRunner::ShouldDumpBackForwardList() const {
   return dump_back_forward_list_;
 }
 
 bool TestRunner::shouldDumpSelectionRect() const {
   return dump_selection_rect_;
 }
 
 bool TestRunner::isPrinting() const {
-  return layout_dump_flags_.is_printing;
+  return layout_dump_flags()->is_printing;
 }
 
 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
   return wait_until_external_url_load_;
 }
 
 const std::set<std::string>* TestRunner::httpHeadersToClear() const {
   return &http_headers_to_clear_;
 }
 
 void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear) {
   if (frame->top()->view() != web_view_)
     return;
   if (!test_is_running_)
     return;
   if (clear) {
     top_loading_frame_ = nullptr;
     LocationChangeDone();
   } else if (!top_loading_frame_) {
     top_loading_frame_ = frame;
   }
 }
 
 WebFrame* TestRunner::topLoadingFrame() const {
   return top_loading_frame_;
 }
 
 void TestRunner::policyDelegateDone() {
-  DCHECK(wait_until_done_);
+  DCHECK(layout_dump_flags()->wait_until_done);
   delegate_->TestFinished();
-  wait_until_done_ = false;
+  layout_dump_flags()->wait_until_done = false;
 }
 
 bool TestRunner::policyDelegateEnabled() const {
   return policy_delegate_enabled_;
 }
 
 bool TestRunner::policyDelegateIsPermissive() const {
   return policy_delegate_is_permissive_;
 }
 
@@ skipping 79 matching lines @@
   if (disable_notify_done_)
     return;
 
   // Test didn't timeout. Kill the timeout timer.
   task_list_.RevokeAll();
 
   CompleteNotifyDone();
 }
 
 void TestRunner::WaitUntilDone() {
-  wait_until_done_ = true;
+  layout_dump_flags()->wait_until_done = true;
 }
 
 void TestRunner::QueueBackNavigation(int how_far_back) {
   work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
 }
 
 void TestRunner::QueueForwardNavigation(int how_far_forward) {
   work_queue_.AddWork(new WorkItemBackForward(how_far_forward));
 }
 
@@ skipping 112 matching lines @@
 
 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) {
   args->GetNext(&policy_delegate_enabled_);
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean())
     args->GetNext(&policy_delegate_is_permissive_);
 }
 
 void TestRunner::WaitForPolicyDelegate() {
   policy_delegate_enabled_ = true;
   policy_delegate_should_notify_done_ = true;
-  wait_until_done_ = true;
+  layout_dump_flags()->wait_until_done = true;
 }
 
 int TestRunner::WindowCount() {
   return test_interfaces_->GetWindowList().size();
 }
 
 void TestRunner::SetCloseRemainingWindowsWhenComplete(
     bool close_remaining_windows) {
   close_remaining_windows_ = close_remaining_windows;
 }
@@ skipping 424 matching lines @@
 
 bool TestRunner::AnimationScheduled() {
   return proxy_->AnimationScheduled();
 }
 
 void TestRunner::DumpEditingCallbacks() {
   dump_editting_callbacks_ = true;
 }
 
 void TestRunner::DumpAsMarkup() {
-  layout_dump_flags_.dump_as_markup = true;
-  generate_pixel_results_ = false;
+  layout_dump_flags()->dump_as_markup = true;
+  layout_dump_flags()->generate_pixel_results = false;
 }
 
 void TestRunner::DumpAsText() {
-  layout_dump_flags_.dump_as_text = true;
-  generate_pixel_results_ = false;
+  layout_dump_flags()->dump_as_text = true;
+  layout_dump_flags()->generate_pixel_results = false;
 }
 
 void TestRunner::DumpAsTextWithPixelResults() {
-  layout_dump_flags_.dump_as_text = true;
-  generate_pixel_results_ = true;
+  layout_dump_flags()->dump_as_text = true;
+  layout_dump_flags()->generate_pixel_results = true;
 }
 
 void TestRunner::DumpChildFrameScrollPositions() {
-  layout_dump_flags_.dump_child_frame_scroll_positions = true;
+  layout_dump_flags()->dump_child_frame_scroll_positions = true;
 }
 
 void TestRunner::DumpChildFramesAsMarkup() {
-  layout_dump_flags_.dump_child_frames_as_markup = true;
+  layout_dump_flags()->dump_child_frames_as_markup = true;
 }
 
 void TestRunner::DumpChildFramesAsText() {
-  layout_dump_flags_.dump_child_frames_as_text = true;
+  layout_dump_flags()->dump_child_frames_as_text = true;
 }
 
 void TestRunner::DumpIconChanges() {
   dump_icon_changes_ = true;
 }
 
 void TestRunner::SetAudioData(const gin::ArrayBufferView& view) {
   unsigned char* bytes = static_cast<unsigned char*>(view.bytes());
   audio_data_.resize(view.num_bytes());
   std::copy(bytes, bytes + view.num_bytes(), audio_data_.begin());
@@ skipping 78 matching lines @@
 
 void TestRunner::DumpBackForwardList() {
   dump_back_forward_list_ = true;
 }
 
 void TestRunner::DumpSelectionRect() {
   dump_selection_rect_ = true;
 }
 
 void TestRunner::SetPrinting() {
-  layout_dump_flags_.is_printing = true;
+  layout_dump_flags()->is_printing = true;
 }
 
 void TestRunner::ClearPrinting() {
-  layout_dump_flags_.is_printing = false;
+  layout_dump_flags()->is_printing = false;
 }
 
 void TestRunner::SetShouldStayOnPageAfterHandlingBeforeUnload(bool value) {
   should_stay_on_page_after_handling_before_unload_ = value;
 }
 
 void TestRunner::SetWillSendRequestClearHeader(const std::string& header) {
   if (!header.empty())
     http_headers_to_clear_.insert(header);
 }
@@ skipping 350 matching lines @@
   task->SetArguments(1, arg);
   InvokeCallback(std::move(task));
 }
 
 void TestRunner::LocationChangeDone() {
   web_history_item_count_ = delegate_->NavigationEntryCount();
 
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
-  if (!wait_until_done_)
+  if (!layout_dump_flags()->wait_until_done)
     work_queue_.ProcessWorkSoon();
 }
 
 void TestRunner::CheckResponseMimeType() {
   // Text output: the test page can request different types of output which we
   // handle here.
-  if (!layout_dump_flags_.dump_as_text) {
+  if (!layout_dump_flags()->dump_as_text) {
     std::string mimeType =
         web_view_->mainFrame()->dataSource()->response().mimeType().utf8();
     if (mimeType == "text/plain") {
-      layout_dump_flags_.dump_as_text = true;
-      generate_pixel_results_ = false;
+      layout_dump_flags()->dump_as_text = true;
+      layout_dump_flags()->generate_pixel_results = false;
     }
   }
 }
 
 void TestRunner::CompleteNotifyDone() {
-  if (wait_until_done_ && !topLoadingFrame() && work_queue_.is_empty())
+  if (layout_dump_flags()->wait_until_done && !topLoadingFrame() &&
+      work_queue_.is_empty())
     delegate_->TestFinished();
-  wait_until_done_ = false;
+  layout_dump_flags()->wait_until_done = false;
 }
 
 void TestRunner::DidAcquirePointerLockInternal() {
   pointer_locked_ = true;
   web_view_->didAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
 void TestRunner::DidNotAcquirePointerLockInternal() {
   DCHECK(!pointer_locked_);
   pointer_locked_ = false;
   web_view_->didNotAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner