Remove duplication between TestRunner's fields and LayoutDumpFlags struct.

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 1657 matching lines @@
   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
+          false,  // dump_line_box_trees
+          false),  // debug_render_tree
       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 50 matching lines @@
     delegate_->DeleteAllCookies();
     delegate_->ResetScreenOrientation();
     delegate_->SetBluetoothMockDataSet("");
     delegate_->ClearGeofencingMockProvider();
     delegate_->ResetPermissions();
     ResetBatteryStatus();
     ResetDeviceLight();
   }
 
   dump_editting_callbacks_ = false;
-  dump_as_text_ = false;
-  dump_as_markup_ = false;
+  layout_dump_flags_.dump_as_text = false;
+  layout_dump_flags_.dump_as_markup = false;
   generate_pixel_results_ = true;
-  dump_child_frame_scroll_positions_ = false;
-  dump_child_frames_as_markup_ = false;
-  dump_child_frames_as_text_ = false;
+  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;
-  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 22 matching lines @@
 }
 
 void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
   delegate_->PostTask(task.release());
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return dump_editting_callbacks_;
 }
 
-bool TestRunner::shouldDumpAsText() {
-  CheckResponseMimeType();
-  return dump_as_text_;
-}
-
 void TestRunner::setShouldDumpAsText(bool value) {
-  dump_as_text_ = value;
-}
-
-bool TestRunner::shouldDumpAsMarkup() {
-  return dump_as_markup_;
+  layout_dump_flags_.dump_as_text = value;
 }
 
 void TestRunner::setShouldDumpAsMarkup(bool value) {
-  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_;
 }
 
 bool TestRunner::ShouldStayOnPageAfterHandlingBeforeUnload() const {
   return should_stay_on_page_after_handling_before_unload_;
 }
 
 
 void TestRunner::setShouldGeneratePixelResults(bool value) {
   generate_pixel_results_ = value;
 }
 
-bool TestRunner::shouldDumpChildFrameScrollPositions() const {
-  return dump_child_frame_scroll_positions_;
-}
-
-bool TestRunner::shouldDumpChildFramesAsMarkup() const {
-  return dump_child_frames_as_markup_;
-}
-
-bool TestRunner::shouldDumpChildFramesAsText() const {
-  return dump_child_frames_as_text_;
-}
-
 bool TestRunner::ShouldDumpAsAudio() const {
   return dump_as_audio_;
 }
 
 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const {
   *buffer_view = audio_data_;
 }
 
-LayoutDumpFlags TestRunner::GetLayoutDumpFlags() {
-  LayoutDumpFlags result;
-
-  if (shouldDumpAsText()) {
-    result.main_dump_mode = LayoutDumpMode::DUMP_AS_TEXT;
-    result.dump_child_frames = shouldDumpChildFramesAsText();
-  } else if (shouldDumpAsMarkup()) {
-    result.main_dump_mode = LayoutDumpMode::DUMP_AS_MARKUP;
-    result.dump_child_frames = shouldDumpChildFramesAsMarkup();
-  } else {
-    result.main_dump_mode = LayoutDumpMode::DUMP_SCROLL_POSITIONS;
-    result.dump_child_frames = shouldDumpChildFrameScrollPositions();
-  }
-
-  result.dump_as_printed = isPrinting();
-
-  result.dump_line_box_trees = result.debug_render_tree = false;
-
-  return result;
+const LayoutDumpFlags& TestRunner::GetLayoutDumpFlags() {
+  CheckResponseMimeType();
+  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 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_;
 }
 
@@ skipping 702 matching lines @@
 
 bool TestRunner::AnimationScheduled() {
   return proxy_->AnimationScheduled();
 }
 
 void TestRunner::DumpEditingCallbacks() {
   dump_editting_callbacks_ = true;
 }
 
 void TestRunner::DumpAsMarkup() {
-  dump_as_markup_ = true;
+  layout_dump_flags_.dump_as_markup = true;
   generate_pixel_results_ = false;
 }
 
 void TestRunner::DumpAsText() {
-  dump_as_text_ = true;
+  layout_dump_flags_.dump_as_text = true;
   generate_pixel_results_ = false;
 }
 
 void TestRunner::DumpAsTextWithPixelResults() {
-  dump_as_text_ = true;
+  layout_dump_flags_.dump_as_text = true;
   generate_pixel_results_ = true;
 }
 
 void TestRunner::DumpChildFrameScrollPositions() {
-  dump_child_frame_scroll_positions_ = true;
+  layout_dump_flags_.dump_child_frame_scroll_positions = true;
 }
 
 void TestRunner::DumpChildFramesAsMarkup() {
-  dump_child_frames_as_markup_ = true;
+  layout_dump_flags_.dump_child_frames_as_markup = true;
 }
 
 void TestRunner::DumpChildFramesAsText() {
-  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() {
-  is_printing_ = true;
+  layout_dump_flags_.is_printing = true;
 }
 
 void TestRunner::ClearPrinting() {
-  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 357 matching lines @@
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
   if (!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 (!dump_as_text_) {
+  if (!layout_dump_flags_.dump_as_text) {
     std::string mimeType =
         web_view_->mainFrame()->dataSource()->response().mimeType().utf8();
     if (mimeType == "text/plain") {
-      dump_as_text_ = true;
+      layout_dump_flags_.dump_as_text = true;
       generate_pixel_results_ = false;
     }
   }
 }
 
 void TestRunner::CompleteNotifyDone() {
   if (wait_until_done_ && !topLoadingFrame() && work_queue_.is_empty())
     delegate_->TestFinished();
   wait_until_done_ = false;
 }
@@ skipping 16 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner