Split //ui/display and create //ui/display/manager.

ui/display/manager/chromeos/x11/native_display_event_dispatcher_x11_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 <stdint.h>
 #include <X11/extensions/Xrandr.h>
 
 #undef Bool
 #undef None
 
 #include "base/macros.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/display/chromeos/x11/display_mode_x11.h"
-#include "ui/display/chromeos/x11/display_snapshot_x11.h"
-#include "ui/display/chromeos/x11/native_display_delegate_x11.h"
-#include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
+#include "ui/display/manager/chromeos/x11/display_mode_x11.h"
+#include "ui/display/manager/chromeos/x11/display_snapshot_x11.h"
+#include "ui/display/manager/chromeos/x11/native_display_delegate_x11.h"
+#include "ui/display/manager/chromeos/x11/native_display_event_dispatcher_x11.h"
 
 namespace ui {
 
 namespace {
 
 DisplaySnapshotX11* CreateOutput(int64_t id,
                                  DisplayConnectionType type,
                                  RROutput output,
                                  RRCrtc crtc) {
-  static const DisplayModeX11 kDefaultDisplayMode(gfx::Size(1, 1),
-                                                  false,
-                                                  60.0f,
+  static const DisplayModeX11 kDefaultDisplayMode(gfx::Size(1, 1), false, 60.0f,
                                                   20);
   std::vector<std::unique_ptr<const DisplayMode>> modes;
   const DisplayMode* mode;
 
   modes.push_back(kDefaultDisplayMode.Clone());
   mode = modes.front().get();
 
   DisplaySnapshotX11* snapshot = new DisplaySnapshotX11(
-      id,
-      gfx::Point(0, 0),
-      gfx::Size(0, 0),
-      type,
-      false,
-      false,
-      std::string(),
-      std::move(modes),
-      std::vector<uint8_t>(),
-      mode,
-      NULL,
-      output,
-      crtc,
-      0);
+      id, gfx::Point(0, 0), gfx::Size(0, 0), type, false, false, std::string(),
+      std::move(modes), std::vector<uint8_t>(), mode, NULL, output, crtc, 0);
 
   return snapshot;
 }
 
 DisplaySnapshotX11* CreateExternalOutput(RROutput output, RRCrtc crtc) {
   return CreateOutput(static_cast<int64_t>(output),
-                      DISPLAY_CONNECTION_TYPE_UNKNOWN,
-                      output,
-                      crtc);
+                      DISPLAY_CONNECTION_TYPE_UNKNOWN, output, crtc);
 }
 
 DisplaySnapshotX11* CreateInternalOutput(RROutput output, RRCrtc crtc) {
-  return CreateOutput(0,
-                      DISPLAY_CONNECTION_TYPE_INTERNAL,
-                      output,
-                      crtc);
+  return CreateOutput(0, DISPLAY_CONNECTION_TYPE_INTERNAL, output, crtc);
 }
 
 class TestHelperDelegate : public NativeDisplayDelegateX11::HelperDelegate {
  public:
   TestHelperDelegate();
   ~TestHelperDelegate() override;
 
   int num_calls_update_xrandr_config() const {
     return num_calls_update_xrandr_config_;
   }
@@ skipping 181 matching lines @@
   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 
   // Simulate removal of second output from cached output list.
   outputs.erase(outputs.begin() + 1);
   helper_delegate_->set_cached_outputs(outputs.get());
 
   DispatchOutputChangeEvent(2, 11, 20, false);
   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 }
 
-TEST_F(NativeDisplayEventDispatcherX11Test,
-       ForceUpdateAfterCacheExpiration) {
+TEST_F(NativeDisplayEventDispatcherX11Test, ForceUpdateAfterCacheExpiration) {
   // +1 to compenstate a possible rounding error.
   const int kHalfOfExpirationMs =
       NativeDisplayEventDispatcherX11::kUseCacheAfterStartupMs / 2 + 1;
 
   ScopedVector<DisplaySnapshot> outputs;
   outputs.push_back(CreateExternalOutput(1, 10));
   outputs.push_back(CreateExternalOutput(2, 11));
   helper_delegate_->set_cached_outputs(outputs.get());
 
   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 
   // Duplicated event will be ignored during the startup.
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 
-  test_tick_clock_->Advance(base::TimeDelta::FromMilliseconds(
-      kHalfOfExpirationMs));
+  test_tick_clock_->Advance(
+      base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
 
   // Duplicated event will still be ignored.
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 
   // The startup timeout has been elapsed. Duplicated event
   // should not be ignored.
   test_tick_clock_->Advance(
       base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 
   // Sending the same event immediately shoudldn't be ignored.
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(2, helper_delegate_->num_calls_notify_observers());
 
   // Advancing time further should not change the behavior.
-  test_tick_clock_->Advance(base::TimeDelta::FromMilliseconds(
-      kHalfOfExpirationMs));
+  test_tick_clock_->Advance(
+      base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(3, helper_delegate_->num_calls_notify_observers());
 
   test_tick_clock_->Advance(
       base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(4, helper_delegate_->num_calls_notify_observers());
 }
 
-TEST_F(NativeDisplayEventDispatcherX11Test,
-       UpdateMissingExternalDisplayId) {
+TEST_F(NativeDisplayEventDispatcherX11Test, UpdateMissingExternalDisplayId) {
   ScopedVector<DisplaySnapshot> outputs;
   outputs.push_back(CreateInternalOutput(1, 10));
   helper_delegate_->set_cached_outputs(outputs.get());
 
   ASSERT_EQ(0, helper_delegate_->num_calls_notify_observers());
 
   // Internal display's ID can be zero and not updated.
   DispatchOutputChangeEvent(1, 10, 20, true);
   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 
   outputs.clear();
   outputs.push_back(CreateOutput(0, DISPLAY_CONNECTION_TYPE_UNKNOWN, 2, 11));
   helper_delegate_->set_cached_outputs(outputs.get());
 
   // External display should be updated if the id is zero.
   DispatchOutputChangeEvent(2, 11, 20, true);
   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 }
 
 }  // namespace ui