Fix namespace for src/ui/display/.

services/ui/display/screen_manager_ozone_unittests.cc

 // Copyright 2016 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 <memory>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 10 matching lines @@
 #include "ui/display/screen.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/fake_display_controller.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/ozone/public/ozone_platform.h"
 
 namespace display {
 
-using ui::DisplayMode;
-using ui::DisplaySnapshot;
 using testing::IsEmpty;
 using testing::SizeIs;
 
 namespace {
 
 // Holds info about the display state we want to test.
 struct DisplayState {
   int64_t id;
   ViewportMetrics metrics;
 };
@@ skipping 63 matching lines @@
 
   std::vector<DisplayState> added_;
   std::vector<DisplayState> modified_;
   std::string changes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreenManagerDelegate);
 };
 
 }  // namespace
 
-// Test fixture with helpers to act like ui::DisplayConfigurator and send
+// Test fixture with helpers to act like DisplayConfigurator and send
 // OnDisplayModeChanged() to ScreenManagerOzone.
 class ScreenManagerOzoneTest : public ui::TaskRunnerTestBase {
  public:
   ScreenManagerOzoneTest() {}
   ~ScreenManagerOzoneTest() override {}
 
   ScreenManagerOzone* screen_manager() { return screen_manager_.get(); }
   TestScreenManagerDelegate* delegate() { return &delegate_; }
 
   // Adds a display snapshot with specified ID and default size.
   void AddDisplay(int64_t id) {
     return AddDisplay(FakeDisplaySnapshot::Builder()
                           .SetId(id)
                           .SetNativeMode(gfx::Size(1024, 768))
                           .Build());
   }
 
-  void AddDisplay(std::unique_ptr<ui::DisplaySnapshot> snapshot) {
+  void AddDisplay(std::unique_ptr<DisplaySnapshot> snapshot) {
     EXPECT_TRUE(fake_display_controller_->AddDisplay(std::move(snapshot)));
     RunAllTasks();
   }
 
   // Removes display snapshot with specified ID.
   void RemoveDisplay(int64_t id) {
     EXPECT_TRUE(fake_display_controller_->RemoveDisplay(id));
     RunAllTasks();
   }
 
   static void SetUpTestCase() { ui::DeviceDataManager::CreateInstance(); }
 
   static void TearDownTestCase() { ui::DeviceDataManager::DeleteInstance(); }
 
  private:
   // testing::Test:
   void SetUp() override {
     TaskRunnerTestBase::SetUp();
 
     base::CommandLine::ForCurrentProcess()->AppendSwitchNative(
         switches::kScreenConfig, "none");
 
     screen_manager_ = base::MakeUnique<ScreenManagerOzone>();
 
     // Create NDD for FakeDisplayController.
-    std::unique_ptr<ui::NativeDisplayDelegate> ndd =
+    std::unique_ptr<NativeDisplayDelegate> ndd =
         base::MakeUnique<FakeDisplayDelegate>();
     fake_display_controller_ = ndd->GetFakeDisplayController();
 
     // Add NDD to ScreenManager so one isn't loaded from Ozone.
     screen_manager_->native_display_delegate_ = std::move(ndd);
 
     AddDisplay(FakeDisplaySnapshot::Builder()
                    .SetId(1)
                    .SetNativeMode(gfx::Size(1024, 768))
-                   .SetType(ui::DISPLAY_CONNECTION_TYPE_INTERNAL)
+                   .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
                    .Build());
 
     screen_manager_->Init(&delegate_);
     RunAllTasks();
 
     // Double check the expected display exists and clear counters.
     ASSERT_THAT(delegate()->added(), SizeIs(1));
     ASSERT_THAT(delegate_.added()[0], DisplayIdIs(1));
     ASSERT_THAT(delegate_.added()[0], DisplayBoundsIs("0,0 1024x768"));
     ASSERT_THAT(delegate_.added()[0], DisplayPixelSizeIs("1024x768"));
@@ skipping 63 matching lines @@
 
   // Check that display 3 was removed.
   RemoveDisplay(3);
   EXPECT_EQ("Removed(3)", delegate()->changes());
 }
 
 TEST_F(ScreenManagerOzoneTest, AddDisplay4k) {
   AddDisplay(FakeDisplaySnapshot::Builder()
                  .SetId(2)
                  .SetNativeMode(gfx::Size(4096, 2160))
-                 .SetType(ui::DISPLAY_CONNECTION_TYPE_DVI)
+                 .SetType(DISPLAY_CONNECTION_TYPE_DVI)
                  .Build());
 
   // Check that display 2 has a device scale factor of 2 since it's a 4k
   // display.
   EXPECT_EQ("Added(2)", delegate()->changes());
   EXPECT_THAT(delegate()->added()[0], DisplayBoundsIs("1024,0 2048x1080"));
   EXPECT_THAT(delegate()->added()[0], DisplayPixelSizeIs("4096x2160"));
 }
 
 TEST_F(ScreenManagerOzoneTest, SwapPrimaryDisplay) {
@@ skipping 13 matching lines @@
 
   // Swapping again should be similar and end up back with display 1 as primary.
   screen_manager()->SwapPrimaryDisplay();
   EXPECT_EQ("Modified(1);Modified(2);Primary(1)", delegate()->changes());
   EXPECT_THAT(delegate()->modified()[0], DisplayBoundsIs("0,0 1024x768"));
   EXPECT_THAT(delegate()->modified()[1], DisplayBoundsIs("1024,0 1024x768"));
   EXPECT_EQ(1, Screen::GetScreen()->GetPrimaryDisplay().id());
 }
 
 }  // namespace display