Replicate across OOPIFs flags for dumping of various WebFrameClient callbacks.

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 1474 matching lines @@
 }
 
 int TestRunnerBindings::WebHistoryItemCount() {
   if (runner_)
     return runner_->web_history_item_count_;
   return false;
 }
 
 bool TestRunnerBindings::InterceptPostMessage() {
   if (runner_)
-    return runner_->intercept_post_message_;
+    return runner_->shouldInterceptPostMessage();
   return false;
 }
 
 void TestRunnerBindings::SetInterceptPostMessage(bool value) {
-  if (runner_)
-    runner_->intercept_post_message_ = value;
+  if (runner_) {
+    runner_->layout_test_runtime_flags_.set_intercept_post_message(value);
+    runner_->OnLayoutTestRuntimeFlagsChanged();
+  }
 }
 
 void TestRunnerBindings::ForceNextWebGLContextCreationToFail() {
   if (runner_)
     runner_->ForceNextWebGLContextCreationToFail();
 }
 
 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() {
   if (runner_)
     runner_->ForceNextDrawingBufferCreationToFail();
@@ skipping 52 matching lines @@
   if (!controller_->layout_test_runtime_flags_.wait_until_done() &&
       !controller_->topLoadingFrame())
     controller_->delegate_->TestFinished();
 }
 
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
       web_history_item_count_(0),
-      intercept_post_message_(false),
       test_interfaces_(interfaces),
       delegate_(nullptr),
       web_view_(nullptr),
       mock_content_settings_client_(
           new MockContentSettingsClient(&layout_test_runtime_flags_)),
       credential_manager_client_(new MockCredentialManagerClient),
       mock_screen_orientation_client_(new MockScreenOrientationClient),
       spellcheck_(new SpellCheckClient(this)),
       chooser_count_(0),
       previously_focused_view_(nullptr),
@@ skipping 32 matching lines @@
     web_view_->mainFrame()->enableViewSourceMode(false);
 
     web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
   }
 
   top_loading_frame_ = nullptr;
   layout_test_runtime_flags_.Reset();
   mock_screen_orientation_client_->ResetData();
   drag_image_.reset();
   views_with_scheduled_animations_.clear();
-  wait_until_external_url_load_ = 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_->SetBluetoothManualChooser(false);
     delegate_->ClearGeofencingMockProvider();
     delegate_->ResetPermissions();
     ResetDeviceLight();
   }
 
-  dump_editting_callbacks_ = 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_response_mime_types_ = false;
   dump_window_status_changes_ = false;
   dump_spell_check_callbacks_ = false;
   dump_back_forward_list_ = false;
-  dump_navigation_policy_ = false;
   test_repaint_ = false;
   sweep_horizontally_ = 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();
   web_history_item_count_ = 0;
-  intercept_post_message_ = false;
 
   SetUseMockTheme(true);
 
   pointer_locked_ = false;
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 
   weak_factory_.InvalidateWeakPtrs();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
@@ skipping 69 matching lines @@
 base::Closure TestRunner::CreateClosureThatPostsV8Callback(
     const v8::Local<v8::Function>& callback) {
   return base::Bind(
       &TestRunner::PostTask, weak_factory_.GetWeakPtr(),
       base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
                  v8::UniquePersistent<v8::Function>(blink::mainThreadIsolate(),
                                                     callback)));
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
-  return dump_editting_callbacks_;
+  return layout_test_runtime_flags_.dump_editting_callbacks();
 }
 
 void TestRunner::setShouldDumpAsText(bool value) {
   layout_test_runtime_flags_.set_dump_as_text(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::setShouldDumpAsMarkup(bool value) {
   layout_test_runtime_flags_.set_dump_as_markup(value);
   OnLayoutTestRuntimeFlagsChanged();
@@ skipping 11 matching lines @@
   custom_text_output_ = text;
   has_custom_text_output_ = true;
 }
 
 bool TestRunner::ShouldGeneratePixelResults() {
   CheckResponseMimeType();
   return layout_test_runtime_flags_.generate_pixel_results();
 }
 
 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const {
-  return should_stay_on_page_after_handling_before_unload_;
+  return layout_test_runtime_flags_.stay_on_page_after_handling_before_unload();
 }
 
 
 void TestRunner::setShouldGeneratePixelResults(bool value) {
   layout_test_runtime_flags_.set_generate_pixel_results(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 bool TestRunner::ShouldDumpAsAudio() const {
   return dump_as_audio_;
@@ skipping 48 matching lines @@
 bool TestRunner::HasCustomTextDump(std::string* custom_text_dump) const {
   if (shouldDumpAsCustomText()) {
     *custom_text_dump = customDumpText();
     return true;
   }
 
   return false;
 }
 
 bool TestRunner::shouldDumpFrameLoadCallbacks() const {
-  return test_is_running_ && dump_frame_load_callbacks_;
+  return test_is_running_ &&
+         layout_test_runtime_flags_.dump_frame_load_callbacks();
 }
 
 void TestRunner::setShouldDumpFrameLoadCallbacks(bool value) {
-  dump_frame_load_callbacks_ = value;
+  layout_test_runtime_flags_.set_dump_frame_load_callbacks(value);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 bool TestRunner::shouldDumpPingLoaderCallbacks() const {
-  return test_is_running_ && dump_ping_loader_callbacks_;
+  return test_is_running_ &&
+         layout_test_runtime_flags_.dump_ping_loader_callbacks();
 }
 
 void TestRunner::setShouldEnableViewSource(bool value) {
   web_view_->mainFrame()->enableViewSourceMode(value);
 }
 
 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const {
-  return test_is_running_ && dump_user_gesture_in_frame_load_callbacks_;
+  return test_is_running_ &&
+         layout_test_runtime_flags_.dump_user_gesture_in_frame_load_callbacks();
 }
 
 bool TestRunner::shouldDumpTitleChanges() const {
-  return dump_title_changes_;
+  return layout_test_runtime_flags_.dump_title_changes();
 }
 
 bool TestRunner::shouldDumpIconChanges() const {
-  return dump_icon_changes_;
+  return layout_test_runtime_flags_.dump_icon_changes();
 }
 
 bool TestRunner::shouldDumpCreateView() const {
   return dump_create_view_;
 }
 
 bool TestRunner::canOpenWindows() const {
   return can_open_windows_;
 }
 
 bool TestRunner::shouldDumpResourceLoadCallbacks() const {
-  return test_is_running_ && dump_resource_load_callbacks_;
+  return test_is_running_ &&
+         layout_test_runtime_flags_.dump_resource_load_callbacks();
 }
 
 bool TestRunner::shouldDumpResourceResponseMIMETypes() const {
-  return test_is_running_ && dump_resource_response_mime_types_;
+  return test_is_running_ &&
+         layout_test_runtime_flags_.dump_resource_response_mime_types();
 }
 
 WebContentSettingsClient* TestRunner::GetWebContentSettings() const {
   return mock_content_settings_client_.get();
 }
 
 void TestRunner::InitializeWebViewWithMocks(blink::WebView* web_view) {
   web_view->setSpellCheckClient(spellcheck_.get());
   web_view->setCredentialManagerClient(credential_manager_client_.get());
 }
 
 bool TestRunner::shouldDumpStatusCallbacks() const {
   return dump_window_status_changes_;
 }
 
 bool TestRunner::shouldDumpSpellCheckCallbacks() const {
   return dump_spell_check_callbacks_;
 }
 
 bool TestRunner::ShouldDumpBackForwardList() const {
   return dump_back_forward_list_;
 }
 
 bool TestRunner::isPrinting() const {
   return layout_test_runtime_flags_.is_printing();
 }
 
 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
-  return wait_until_external_url_load_;
+  return layout_test_runtime_flags_.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_)
@@ skipping 23 matching lines @@
 
 bool TestRunner::policyDelegateIsPermissive() const {
   return layout_test_runtime_flags_.policy_delegate_is_permissive();
 }
 
 bool TestRunner::policyDelegateShouldNotifyDone() const {
   return layout_test_runtime_flags_.policy_delegate_should_notify_done();
 }
 
 bool TestRunner::shouldInterceptPostMessage() const {
-  return intercept_post_message_;
+  return layout_test_runtime_flags_.intercept_post_message();
 }
 
 bool TestRunner::shouldDumpResourcePriorities() const {
-  return should_dump_resource_priorities_;
+  return layout_test_runtime_flags_.dump_resource_priorities();
 }
 
 bool TestRunner::RequestPointerLock() {
   switch (pointer_lock_planned_result_) {
     case PointerLockWillSucceed:
       PostDelayedTask(0, base::Bind(&TestRunner::DidAcquirePointerLockInternal,
                                     weak_factory_.GetWeakPtr()));
       return true;
     case PointerLockWillRespondAsync:
       DCHECK(!pointer_locked_);
@@ skipping 22 matching lines @@
 
 void TestRunner::setDragImage(
     const blink::WebImage& drag_image) {
   if (layout_test_runtime_flags_.dump_drag_image()) {
     if (drag_image_.isNull())
       drag_image_ = drag_image;
   }
 }
 
 bool TestRunner::shouldDumpNavigationPolicy() const {
-  return dump_navigation_policy_;
+  return layout_test_runtime_flags_.dump_navigation_policy();
 }
 
 bool TestRunner::midiAccessorResult() {
   return midi_accessor_result_;
 }
 
 void TestRunner::ClearDevToolsLocalStorage() {
   delegate_->ClearDevToolsLocalStorage();
 }
 
@@ skipping 607 matching lines @@
 
 void TestRunner::OnAnimationScheduled(blink::WebView* view) {
   views_with_scheduled_animations_.insert(view);
 }
 
 void TestRunner::OnAnimationBegun(blink::WebView* view) {
   views_with_scheduled_animations_.erase(view);
 }
 
 void TestRunner::DumpEditingCallbacks() {
-  dump_editting_callbacks_ = true;
+  layout_test_runtime_flags_.set_dump_editting_callbacks(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpAsMarkup() {
   layout_test_runtime_flags_.set_dump_as_markup(true);
   layout_test_runtime_flags_.set_generate_pixel_results(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpAsText() {
   layout_test_runtime_flags_.set_dump_as_text(true);
@@ skipping 16 matching lines @@
   layout_test_runtime_flags_.set_dump_child_frames_as_markup(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpChildFramesAsText() {
   layout_test_runtime_flags_.set_dump_child_frames_as_text(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpIconChanges() {
-  dump_icon_changes_ = true;
+  layout_test_runtime_flags_.set_dump_icon_changes(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 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());
   dump_as_audio_ = true;
 }
 
 void TestRunner::DumpFrameLoadCallbacks() {
-  dump_frame_load_callbacks_ = true;
+  layout_test_runtime_flags_.set_dump_frame_load_callbacks(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpPingLoaderCallbacks() {
-  dump_ping_loader_callbacks_ = true;
+  layout_test_runtime_flags_.set_dump_ping_loader_callbacks(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpUserGestureInFrameLoadCallbacks() {
-  dump_user_gesture_in_frame_load_callbacks_ = true;
+  layout_test_runtime_flags_.set_dump_user_gesture_in_frame_load_callbacks(
+      true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpTitleChanges() {
-  dump_title_changes_ = true;
+  layout_test_runtime_flags_.set_dump_title_changes(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpCreateView() {
   dump_create_view_ = true;
 }
 
 void TestRunner::SetCanOpenWindows() {
   can_open_windows_ = true;
 }
 
 void TestRunner::DumpResourceLoadCallbacks() {
-  dump_resource_load_callbacks_ = true;
+  layout_test_runtime_flags_.set_dump_resource_load_callbacks(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpResourceResponseMIMETypes() {
-  dump_resource_response_mime_types_ = true;
+  layout_test_runtime_flags_.set_dump_resource_response_mime_types(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetImagesAllowed(bool allowed) {
   layout_test_runtime_flags_.set_images_allowed(allowed);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetMediaAllowed(bool allowed) {
   layout_test_runtime_flags_.set_media_allowed(allowed);
   OnLayoutTestRuntimeFlagsChanged();
@@ skipping 51 matching lines @@
   layout_test_runtime_flags_.set_is_printing(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::ClearPrinting() {
   layout_test_runtime_flags_.set_is_printing(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetShouldStayOnPageAfterHandlingBeforeUnload(bool value) {
-  should_stay_on_page_after_handling_before_unload_ = value;
+  layout_test_runtime_flags_.set_stay_on_page_after_handling_before_unload(
+      value);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetWillSendRequestClearHeader(const std::string& header) {
   if (!header.empty())
     http_headers_to_clear_.insert(header);
 }
 
 void TestRunner::DumpResourceRequestPriorities() {
-  should_dump_resource_priorities_ = true;
+  layout_test_runtime_flags_.set_dump_resource_priorities(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetUseMockTheme(bool use) {
   use_mock_theme_ = use;
   blink::setMockThemeEnabledForTest(use);
 }
 
 void TestRunner::ShowWebInspector(const std::string& str,
                                   const std::string& frontend_url) {
   ShowDevTools(str, frontend_url);
 }
 
 void TestRunner::WaitUntilExternalURLLoad() {
-  wait_until_external_url_load_ = true;
+  layout_test_runtime_flags_.set_wait_until_external_url_load(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpDragImage() {
   layout_test_runtime_flags_.set_dump_drag_image(true);
   DumpAsTextWithPixelResults();
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpNavigationPolicy() {
-  dump_navigation_policy_ = true;
+  layout_test_runtime_flags_.set_dump_navigation_policy(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpPageImportanceSignals() {
   blink::WebPageImportanceSignals* signals =
     web_view_->pageImportanceSignals();
   if (!signals)
     return;
 
   std::string message = base::StringPrintf(
       "WebPageImportanceSignals:\n"
@@ skipping 427 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner