clang-format all of //ash

ash/display/display_manager_unittest.cc

 // Copyright (c) 2012 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 "ash/display/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/display/display_info.h"
 #include "ash/common/material_design/material_design_controller.h"
@@ skipping 42 matching lines @@
 
 }  // namespace
 
 class DisplayManagerTest : public test::AshMDTestBase,
                            public display::DisplayObserver,
                            public aura::WindowObserver {
  public:
   DisplayManagerTest()
       : removed_count_(0U),
         root_window_destroyed_(false),
-        changed_metrics_(0U) {
-  }
+        changed_metrics_(0U) {}
   ~DisplayManagerTest() override {}
 
   void SetUp() override {
     AshMDTestBase::SetUp();
     display::Screen::GetScreen()->AddObserver(this);
     Shell::GetPrimaryRootWindow()->AddObserver(this);
   }
   void TearDown() override {
     Shell::GetPrimaryRootWindow()->RemoveObserver(this);
     display::Screen::GetScreen()->RemoveObserver(this);
     AshMDTestBase::TearDown();
   }
 
   DisplayManager* display_manager() {
     return Shell::GetInstance()->display_manager();
   }
   const vector<display::Display>& changed() const { return changed_; }
   const vector<display::Display>& added() const { return added_; }
   uint32_t changed_metrics() const { return changed_metrics_; }
 
   string GetCountSummary() const {
-    return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS,
-                        changed_.size(), added_.size(), removed_count_);
+    return StringPrintf("%" PRIuS " %" PRIuS " %" PRIuS, changed_.size(),
+                        added_.size(), removed_count_);
   }
 
   void reset() {
     changed_.clear();
     added_.clear();
     removed_count_ = 0U;
     changed_metrics_ = 0U;
     root_window_destroyed_ = false;
   }
 
-  bool root_window_destroyed() const {
-    return root_window_destroyed_;
-  }
+  bool root_window_destroyed() const { return root_window_destroyed_; }
 
   const DisplayInfo& GetDisplayInfo(const display::Display& display) {
     return display_manager()->GetDisplayInfo(display.id());
   }
 
   const DisplayInfo& GetDisplayInfoAt(int index) {
     return GetDisplayInfo(display_manager()->GetDisplayAt(index));
   }
 
   const display::Display& GetDisplayForId(int64_t id) {
@@ skipping 366 matching lines @@
 
 TEST_P(DisplayManagerTest, OverscanInsetsTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("0+0-500x500,0+501-400x400");
   reset();
   ASSERT_EQ(2u, display_manager()->GetNumDisplays());
   const DisplayInfo& display_info1 = GetDisplayInfoAt(0);
   const DisplayInfo& display_info2 = GetDisplayInfoAt(1);
-  display_manager()->SetOverscanInsets(
-      display_info2.id(), gfx::Insets(13, 12, 11, 10));
+  display_manager()->SetOverscanInsets(display_info2.id(),
+                                       gfx::Insets(13, 12, 11, 10));
 
   std::vector<display::Display> changed_displays = changed();
   EXPECT_EQ(1u, changed_displays.size());
   EXPECT_EQ(display_info2.id(), changed_displays[0].id());
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   DisplayInfo updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
-  EXPECT_EQ("378x376",
-            updated_display_info2.size_in_pixel().ToString());
+  EXPECT_EQ("378x376", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("13,12,11,10",
             updated_display_info2.overscan_insets_in_dip().ToString());
   EXPECT_EQ("500,0 378x376",
             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
 
   // Make sure that SetOverscanInsets() is idempotent.
   display_manager()->SetOverscanInsets(display_info1.id(), gfx::Insets());
-  display_manager()->SetOverscanInsets(
-      display_info2.id(), gfx::Insets(13, 12, 11, 10));
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
+  display_manager()->SetOverscanInsets(display_info2.id(),
+                                       gfx::Insets(13, 12, 11, 10));
+  EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
-  EXPECT_EQ("378x376",
-            updated_display_info2.size_in_pixel().ToString());
+  EXPECT_EQ("378x376", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("13,12,11,10",
             updated_display_info2.overscan_insets_in_dip().ToString());
 
-  display_manager()->SetOverscanInsets(
-      display_info2.id(), gfx::Insets(10, 11, 12, 13));
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
-  EXPECT_EQ("376x378",
-            GetDisplayInfoAt(1).size_in_pixel().ToString());
+  display_manager()->SetOverscanInsets(display_info2.id(),
+                                       gfx::Insets(10, 11, 12, 13));
+  EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("376x378", GetDisplayInfoAt(1).size_in_pixel().ToString());
   EXPECT_EQ("10,11,12,13",
             GetDisplayInfoAt(1).overscan_insets_in_dip().ToString());
 
   // Recreate a new 2nd display. It won't apply the overscan inset because the
   // new display has a different ID.
   UpdateDisplay("0+0-500x500");
   UpdateDisplay("0+0-500x500,0+501-400x400");
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
-  EXPECT_EQ("0,501 400x400",
-            GetDisplayInfoAt(1).bounds_in_native().ToString());
+  EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("0,501 400x400", GetDisplayInfoAt(1).bounds_in_native().ToString());
 
   // Recreate the displays with the same ID.  It should apply the overscan
   // inset.
   UpdateDisplay("0+0-500x500");
   std::vector<DisplayInfo> display_info_list;
   display_info_list.push_back(display_info1);
   display_info_list.push_back(display_info2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
-  EXPECT_EQ("1,1 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("1,1 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   updated_display_info2 = GetDisplayInfoAt(1);
-  EXPECT_EQ("376x378",
-            updated_display_info2.size_in_pixel().ToString());
+  EXPECT_EQ("376x378", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("10,11,12,13",
             updated_display_info2.overscan_insets_in_dip().ToString());
 
   // HiDPI but overscan display. The specified insets size should be doubled.
   UpdateDisplay("0+0-500x500,0+501-400x400*2");
-  display_manager()->SetOverscanInsets(
-      display_manager()->GetDisplayAt(1).id(), gfx::Insets(4, 5, 6, 7));
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
+  display_manager()->SetOverscanInsets(display_manager()->GetDisplayAt(1).id(),
+                                       gfx::Insets(4, 5, 6, 7));
+  EXPECT_EQ("0,0 500x500", GetDisplayInfoAt(0).bounds_in_native().ToString());
   updated_display_info2 = GetDisplayInfoAt(1);
   EXPECT_EQ("0,501 400x400",
             updated_display_info2.bounds_in_native().ToString());
-  EXPECT_EQ("376x380",
-            updated_display_info2.size_in_pixel().ToString());
+  EXPECT_EQ("376x380", updated_display_info2.size_in_pixel().ToString());
   EXPECT_EQ("4,5,6,7",
             updated_display_info2.overscan_insets_in_dip().ToString());
   EXPECT_EQ("8,10,12,14",
             updated_display_info2.GetOverscanInsetsInPixel().ToString());
 
   // Make sure switching primary display applies the overscan offset only once.
   ash::Shell::GetInstance()->window_tree_host_manager()->SetPrimaryDisplayId(
       ScreenUtil::GetSecondaryDisplay().id());
   EXPECT_EQ("-500,0 500x500",
             ScreenUtil::GetSecondaryDisplay().bounds().ToString());
-  EXPECT_EQ("0,0 500x500",
-            GetDisplayInfo(ScreenUtil::GetSecondaryDisplay()).
-            bounds_in_native().ToString());
+  EXPECT_EQ("0,0 500x500", GetDisplayInfo(ScreenUtil::GetSecondaryDisplay())
+                               .bounds_in_native()
+                               .ToString());
   EXPECT_EQ("0,501 400x400",
             GetDisplayInfo(display::Screen::GetScreen()->GetPrimaryDisplay())
                 .bounds_in_native()
                 .ToString());
   EXPECT_EQ(
       "0,0 188x190",
       display::Screen::GetScreen()->GetPrimaryDisplay().bounds().ToString());
 
   // Make sure just moving the overscan area should property notify observers.
   UpdateDisplay("0+0-500x500");
@@ skipping 203 matching lines @@
   // and exit mirroring.
   display_info_list.clear();
   display_info_list.push_back(internal_display_info);
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(2U, display_manager()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager()->num_connected_displays());
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ("0,0 500x500",
             GetDisplayForId(internal_display_id).bounds().ToString());
-  EXPECT_EQ("500,0 100x100",
-            GetDisplayForId(10).bounds().ToString());
+  EXPECT_EQ("500,0 100x100", GetDisplayForId(10).bounds().ToString());
 
   // Turn off internal
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ(invalid_id, GetDisplayForId(internal_display_id).id());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(external_id).bounds_in_native().ToString());
   EXPECT_EQ(1U, display_manager()->num_connected_displays());
@@ skipping 54 matching lines @@
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
 
   // Connect another display which will become primary.
   const DisplayInfo external_display_info =
       CreateDisplayInfo(10, gfx::Rect(1, 1, 100, 100));
   display_info_list.push_back(external_display_info);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager()->GetNumDisplays());
   EXPECT_EQ("1,1 100x100",
             GetDisplayInfoForId(10).bounds_in_native().ToString());
-  EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()->GetHost()->
-      GetBounds().size().ToString());
+  EXPECT_EQ("100x100", ash::Shell::GetPrimaryRootWindow()
+                           ->GetHost()
+                           ->GetBounds()
+                           .size()
+                           .ToString());
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, NativeDisplaysChangedAfterPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
 
   const int64_t internal_display_id =
       test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   const DisplayInfo native_display_info =
@@ skipping 139 matching lines @@
     EXPECT_TRUE(mode.native);
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 TEST_P(DisplayManagerTest, Rotate) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("100x200/r,300x400/l");
-  EXPECT_EQ("1,1 100x200",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
-  EXPECT_EQ("200x100",
-            GetDisplayInfoAt(0).size_in_pixel().ToString());
+  EXPECT_EQ("1,1 100x200", GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("200x100", GetDisplayInfoAt(0).size_in_pixel().ToString());
 
-  EXPECT_EQ("1,201 300x400",
-            GetDisplayInfoAt(1).bounds_in_native().ToString());
-  EXPECT_EQ("400x300",
-            GetDisplayInfoAt(1).size_in_pixel().ToString());
+  EXPECT_EQ("1,201 300x400", GetDisplayInfoAt(1).bounds_in_native().ToString());
+  EXPECT_EQ("400x300", GetDisplayInfoAt(1).size_in_pixel().ToString());
   reset();
   UpdateDisplay("100x200/b,300x400");
   EXPECT_EQ("2 0 0", GetCountSummary());
   reset();
 
-  EXPECT_EQ("1,1 100x200",
-            GetDisplayInfoAt(0).bounds_in_native().ToString());
-  EXPECT_EQ("100x200",
-            GetDisplayInfoAt(0).size_in_pixel().ToString());
+  EXPECT_EQ("1,1 100x200", GetDisplayInfoAt(0).bounds_in_native().ToString());
+  EXPECT_EQ("100x200", GetDisplayInfoAt(0).size_in_pixel().ToString());
 
-  EXPECT_EQ("1,201 300x400",
-            GetDisplayInfoAt(1).bounds_in_native().ToString());
-  EXPECT_EQ("300x400",
-            GetDisplayInfoAt(1).size_in_pixel().ToString());
+  EXPECT_EQ("1,201 300x400", GetDisplayInfoAt(1).bounds_in_native().ToString());
+  EXPECT_EQ("300x400", GetDisplayInfoAt(1).size_in_pixel().ToString());
 
   // Just Rotating display will change the bounds on both display.
   UpdateDisplay("100x200/l,300x400");
   EXPECT_EQ("2 0 0", GetCountSummary());
   reset();
 
   // Updating to the same configuration should report no changes.
   UpdateDisplay("100x200/l,300x400");
   EXPECT_EQ("0 0 0", GetCountSummary());
   reset();
@@ skipping 534 matching lines @@
 TEST_P(DisplayManagerTest, SoftwareMirroringWithCompositingCursor) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("300x400,400x500");
 
   test::MirrorWindowTestApi test_api;
   EXPECT_EQ(nullptr, test_api.GetHost());
 
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
-  DisplayInfo secondary_info = display_manager->GetDisplayInfo(
-      ScreenUtil::GetSecondaryDisplay().id());
+  DisplayInfo secondary_info =
+      display_manager->GetDisplayInfo(ScreenUtil::GetSecondaryDisplay().id());
 
   display_manager->SetSoftwareMirroring(true);
   display_manager->UpdateDisplays();
 
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   EXPECT_FALSE(root_windows[0]->Contains(test_api.GetCursorWindow()));
 
   Shell::GetInstance()->SetCursorCompositingEnabled(true);
 
   EXPECT_TRUE(root_windows[0]->Contains(test_api.GetCursorWindow()));
@@ skipping 508 matching lines @@
   display::DisplayLayoutBuilder builder(1);
   builder.AddDisplayPlacement(2, 1, display::DisplayPlacement::LEFT, 0);
   builder.AddDisplayPlacement(3, 1, display::DisplayPlacement::BOTTOM, 0);
 
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
 }
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
-  ScreenShutdownTest() {
-  }
+  ScreenShutdownTest() {}
   ~ScreenShutdownTest() override {}
 
   void TearDown() override {
     display::Screen* orig_screen = display::Screen::GetScreen();
     AshTestBase::TearDown();
     if (!SupportsMultipleDisplays())
       return;
     display::Screen* screen = display::Screen::GetScreen();
     EXPECT_NE(orig_screen, screen);
     EXPECT_EQ(2, screen->GetNumDisplays());
@@ skipping 14 matching lines @@
 }
 
 #if defined(OS_CHROMEOS)
 namespace {
 
 // A helper class that sets the display configuration and starts ash.
 // This is to make sure the font configuration happens during ash
 // initialization process.
 class FontTestHelper : public test::AshTestBase {
  public:
-  enum DisplayType {
-    INTERNAL,
-    EXTERNAL
-  };
+  enum DisplayType { INTERNAL, EXTERNAL };
 
   FontTestHelper(float scale, DisplayType display_type) {
     gfx::ClearFontRenderParamsCacheForTest();
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     if (display_type == INTERNAL)
       command_line->AppendSwitch(switches::kAshUseFirstDisplayAsInternal);
     command_line->AppendSwitchASCII(switches::kAshHostWindowBounds,
                                     StringPrintf("1000x800*%f", scale));
     SetUp();
   }
 
   ~FontTestHelper() override { TearDown(); }
 
   // test::AshTestBase:
   void TestBody() override { NOTREACHED(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FontTestHelper);
 };
 
-
 bool IsTextSubpixelPositioningEnabled() {
   gfx::FontRenderParams params =
       gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(), nullptr);
   return params.subpixel_positioning;
 }
 
 gfx::FontRenderParams::Hinting GetFontHintingParams() {
   gfx::FontRenderParams params =
       gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(), nullptr);
   return params.hinting;
@@ skipping 139 matching lines @@
   const display::DisplayLayout& stored =
       layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash