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 1718 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_markup = false;
+  layout_dump_flags_.dump_child_frames_as_text = false;
+  layout_dump_flags_.dump_line_box_trees = false;
+  layout_dump_flags_.debug_render_tree = 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();

[dcheng, 2016/02/23 18:26:35]

Why is this line here?

[Łukasz Anforowicz, 2016/02/23 18:45:26]

Previously this call was made by shouldDumpAsText function (removed in this CL /
called by the old version of GetLayoutDumpFlags).

+  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 698 matching lines @@
 void TestRunner::SetPluginsEnabled(bool enabled) {
   delegate_->Preferences()->plugins_enabled = enabled;
   delegate_->ApplyPreferences();
 }
 
 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