Remove DisplayState from the public interface for DisplayConfigurator

ui/display/chromeos/update_display_configuration_task_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/chromeos/test/action_logger_util.h"
 #include "ui/display/chromeos/test/test_display_snapshot.h"
@@ skipping 33 matching lines @@
   }
 
   MultipleDisplayState GetDisplayState() const override {
     return display_state_;
   }
 
   chromeos::DisplayPowerState GetPowerState() const override {
     return power_state_;
   }
 
-  std::vector<DisplayConfigurator::DisplayState> ParseDisplays(
-      const std::vector<DisplaySnapshot*>& displays) const override {
-    std::vector<DisplayConfigurator::DisplayState> parsed_displays;
+  bool GetDisplayLayout(const std::vector<DisplaySnapshot*>& displays,
+                        MultipleDisplayState new_display_state,
+                        chromeos::DisplayPowerState new_power_state,
+                        std::vector<DisplayConfigureRequest>* requests,
+                        gfx::Size* framebuffer_size) const override {
+    gfx::Point origin;
     for (DisplaySnapshot* display : displays) {
-      DisplayConfigurator::DisplayState state;
-      state.display = display;
-      state.selected_mode = display->native_mode();
-      if (should_mirror_)
-        state.mirror_mode = FindMirrorMode(displays);
-
-      parsed_displays.push_back(state);
-    }
-
-    return parsed_displays;
-  }
-
-  bool GetDisplayLayout(
-      const std::vector<DisplayConfigurator::DisplayState>& displays,
-      MultipleDisplayState new_display_state,
-      chromeos::DisplayPowerState new_power_state,
-      std::vector<DisplayConfigureRequest>* requests,
-      gfx::Size* framebuffer_size) const override {
-    gfx::Point origin;
-    for (const DisplayConfigurator::DisplayState& state : displays) {
-      const DisplayMode* mode = state.selected_mode;
-      if (new_display_state == MULTIPLE_DISPLAY_STATE_DUAL_MIRROR)
-        mode = state.mirror_mode;
+      const DisplayMode* mode = display->native_mode();
+      if (new_display_state == MULTIPLE_DISPLAY_STATE_DUAL_MIRROR) {
+        if (should_mirror_)
+          mode = FindMirrorMode(displays);
+        else
+          mode = nullptr;

[oshima, 2015/03/18 23:02:45]

ternary operator?

[dnicoara, 2015/03/19 14:47:36]

Done.

+      }
 
       if (!mode)
         return false;
 
       if (new_power_state == chromeos::DISPLAY_POWER_ALL_ON) {
-        requests->push_back(
-            DisplayConfigureRequest(state.display, mode, origin));
+        requests->push_back(DisplayConfigureRequest(display, mode, origin));
       } else {
-        requests->push_back(
-            DisplayConfigureRequest(state.display, nullptr, origin));
+        requests->push_back(DisplayConfigureRequest(display, nullptr, origin));
       }
 
       if (new_display_state != MULTIPLE_DISPLAY_STATE_DUAL_MIRROR) {
-        origin.Offset(0, state.selected_mode->size().height());
+        origin.Offset(0, mode->size().height());
         framebuffer_size->SetToMax(gfx::Size(mode->size().width(), origin.y()));
       } else {
         *framebuffer_size = mode->size();
       }
     }
 
     return true;
   }
 
  private:
@@ skipping 43 matching lines @@
   ~UpdateDisplayConfigurationTaskTest() override {}
 
   void UpdateDisplays(size_t count) {
     std::vector<DisplaySnapshot*> displays;
     for (size_t i = 0; i < count; ++i)
       displays.push_back(&displays_[i]);
 
     delegate_.set_outputs(displays);
   }
 
-  void ResponseCallback(
-      bool success,
-      const std::vector<DisplayConfigurator::DisplayState>& displays,
-      const gfx::Size& framebuffer_size,
-      MultipleDisplayState new_display_state,
-      chromeos::DisplayPowerState new_power_state) {
+  void ResponseCallback(bool success,
+                        const std::vector<DisplaySnapshot*>& displays,
+                        const gfx::Size& framebuffer_size,
+                        MultipleDisplayState new_display_state,
+                        chromeos::DisplayPowerState new_power_state) {
     configured_ = true;
     configuration_status_ = success;
     display_states_ = displays;
     display_state_ = new_display_state;
     power_state_ = new_power_state;
 
     if (success) {
       layout_manager_.set_display_state(display_state_);
       layout_manager_.set_power_state(power_state_);
     }
   }
 
  protected:
   ActionLogger log_;
   TestNativeDisplayDelegate delegate_;
   TestDisplayLayoutManager layout_manager_;
 
   const DisplayMode small_mode_;
   const DisplayMode big_mode_;
 
   TestDisplaySnapshot displays_[2];
 
   bool configured_;
   bool configuration_status_;
-  std::vector<DisplayConfigurator::DisplayState> display_states_;
+  std::vector<DisplaySnapshot*> display_states_;
   MultipleDisplayState display_state_;
   chromeos::DisplayPowerState power_state_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UpdateDisplayConfigurationTaskTest);
 };
 
 }  // namespace
 
 TEST_F(UpdateDisplayConfigurationTaskTest, HeadlessConfiguration) {
@@ skipping 178 matching lines @@
   EXPECT_EQ(
       JoinActions(kGrab, GetFramebufferAction(small_mode_.size(), &displays_[0],
                                               nullptr).c_str(),
                   GetCrtcAction(displays_[0], nullptr, gfx::Point()).c_str(),
                   kUngrab, NULL),
       log_.GetActionsAndClear());
 }
 
 }  // namespace test
 }  // namespace ui