Replicating LayoutDumpFlags across OOPIFs.

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>
 
@@ skipping 1592 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
       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;
+  layout_dump_flags_.Reset();
   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;
   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;
   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 23 matching lines @@
 
 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_.set_dump_as_text(value);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::setShouldDumpAsMarkup(bool value) {
-  layout_dump_flags_.dump_as_markup = value;
+  layout_dump_flags_.set_dump_as_markup(value);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_generate_pixel_results(value);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_;
 }
 
+void TestRunner::ReplicateLayoutDumpFlagsChanges(
+    const base::DictionaryValue& changed_values) {
+  layout_dump_flags_.tracked_dictionary().ApplyUntrackedChanges(changed_values);
+}
+
 bool TestRunner::HasCustomTextDump(std::string* custom_text_dump) const {
   if (shouldDumpAsCustomText()) {
     *custom_text_dump = customDumpText();
     return true;
   }
 
   return false;
 }
 
 bool TestRunner::shouldDumpFrameLoadCallbacks() const {
@@ skipping 62 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_.set_wait_until_done(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_wait_until_done(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_wait_until_done(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_dump_as_markup(true);
+  layout_dump_flags_.set_generate_pixel_results(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::DumpAsText() {
-  layout_dump_flags_.dump_as_text = true;
-  generate_pixel_results_ = false;
+  layout_dump_flags_.set_dump_as_text(true);
+  layout_dump_flags_.set_generate_pixel_results(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::DumpAsTextWithPixelResults() {
-  layout_dump_flags_.dump_as_text = true;
-  generate_pixel_results_ = true;
+  layout_dump_flags_.set_dump_as_text(true);
+  layout_dump_flags_.set_generate_pixel_results(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::DumpChildFrameScrollPositions() {
-  layout_dump_flags_.dump_child_frame_scroll_positions = true;
+  layout_dump_flags_.set_dump_child_frame_scroll_positions(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::DumpChildFramesAsMarkup() {
-  layout_dump_flags_.dump_child_frames_as_markup = true;
+  layout_dump_flags_.set_dump_child_frames_as_markup(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::DumpChildFramesAsText() {
-  layout_dump_flags_.dump_child_frames_as_text = true;
+  layout_dump_flags_.set_dump_child_frames_as_text(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_is_printing(true);
+  OnLayoutDumpFlagsChanged();
 }
 
 void TestRunner::ClearPrinting() {
-  layout_dump_flags_.is_printing = false;
+  layout_dump_flags_.set_is_printing(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 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 233 matching lines @@
 }
 
 void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
                                         weak_factory_.GetWeakPtr(),
                                         base::Passed(&task)));
 }
 
+void TestRunner::OnLayoutDumpFlagsChanged() {
+  if (layout_dump_flags_.tracked_dictionary().changed_values().size() == 0)

[dcheng, 2016/03/08 23:09:37]

.empty()?

[Łukasz Anforowicz, 2016/03/10 22:24:21]

Done.

+    return;
+
+  delegate_->OnLayoutDumpFlagsChanged(&layout_dump_flags_);

[dcheng, 2016/03/08 23:09:37]

Nit: pass a const ref, I don't see a place that actually needs this to be an
optional value.

[Łukasz Anforowicz, 2016/03/10 22:24:21]

Done.  I've moved responsibility for deciding when to reset change tracking from
BlinkTestRunner to TestRunner.  I think this is ok, but please read the
explanation below to sanity check.

This cannot be "const", because BlinkTestRunner::OnLayoutDumpFlagsChanged
currently calls
|layout_dump_flags->tracked_dictionary().ResetChangeTracking();|.  Looking at it
again, I am not sure why I thought that ResetChangeTracking should be called by
BlinkTestRunner, rather than by TestRunner.  It felt safer to only reset change
tracking at the exact moment when sending the changes to the browser.  OTOH, we
only skip changes when !is_main_window (and the changes prior to that will be
cloberred anyway by ResetChangeTracking called from LayoutTestFlags::Reset).

+}
+
 void TestRunner::ForceNextWebGLContextCreationToFail() {
   if (web_view_)
     web_view_->forceNextWebGLContextCreationToFail();
 }
 
 void TestRunner::ForceNextDrawingBufferCreationToFail() {
   if (web_view_)
     web_view_->forceNextDrawingBufferCreationToFail();
 }
 
@@ skipping 97 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) {
-    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;
-    }
-  }
+
+  if (layout_dump_flags_.dump_as_text())
+    return;
+
+  WebDataSource* data_source = web_view_->mainFrame()->dataSource();
+  if (!data_source)
+    return;
+
+  std::string mimeType = data_source->response().mimeType().utf8();
+  if (mimeType != "text/plain")
+    return;
+
+  layout_dump_flags_.set_dump_as_text(true);
+  layout_dump_flags_.set_generate_pixel_results(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 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_.set_wait_until_done(false);
+  OnLayoutDumpFlagsChanged();
 }
 
 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