clang-format all of //ash

ash/wm/dock/docked_window_resizer_unittest.cc

 // Copyright (c) 2013 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/common/wm/dock/docked_window_resizer.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_types.h"
@@ skipping 57 matching lines @@
   int min_dock_gap() const { return DockedWindowLayoutManager::kMinDockGap; }
   int max_width() const { return DockedWindowLayoutManager::kMaxDockWidth; }
   int docked_width(const DockedWindowLayoutManager* layout_manager) const {
     return layout_manager->docked_width_;
   }
   int docked_alignment(const DockedWindowLayoutManager* layout_manager) const {
     return layout_manager->alignment_;
   }
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
-        &delegate_,
-        window_type_,
-        0,
-        bounds);
+        &delegate_, window_type_, 0, bounds);
     if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) {
       test::TestShelfDelegate* shelf_delegate =
           test::TestShelfDelegate::instance();
       shelf_delegate->AddShelfItem(window);
       PanelLayoutManager* manager =
           PanelLayoutManager::Get(WmWindowAura::Get(window));
       manager->Relayout();
     }
     return window;
   }
@@ skipping 28 matching lines @@
     return CreateWindowResizer(WmWindowAura::Get(window), point_in_parent,
                                window_component,
                                aura::client::WINDOW_MOVE_SOURCE_MOUSE)
         .release();
   }
 
   void DragStart(aura::Window* window) {
     DragStartAtOffsetFromWindowOrigin(window, 0, 0);
   }
 
-  void DragStartAtOffsetFromWindowOrigin(aura::Window* window,
-                                         int dx, int dy) {
+  void DragStartAtOffsetFromWindowOrigin(aura::Window* window, int dx, int dy) {
     initial_location_in_parent_ =
         window->bounds().origin() + gfx::Vector2d(dx, dy);
-    resizer_.reset(CreateSomeWindowResizer(window,
-                                           initial_location_in_parent_,
+    resizer_.reset(CreateSomeWindowResizer(window, initial_location_in_parent_,
                                            HTCAPTION));
     ASSERT_TRUE(resizer_.get());
   }
 
   void ResizeStartAtOffsetFromWindowOrigin(aura::Window* window,
-                                           int dx, int dy,
+                                           int dx,
+                                           int dy,
                                            int window_component) {
     initial_location_in_parent_ =
         window->bounds().origin() + gfx::Vector2d(dx, dy);
-    resizer_.reset(CreateSomeWindowResizer(window,
-                                           initial_location_in_parent_,
+    resizer_.reset(CreateSomeWindowResizer(window, initial_location_in_parent_,
                                            window_component));
     ASSERT_TRUE(resizer_.get());
   }
 
   void DragMove(int dx, int dy) {
     resizer_->Drag(initial_location_in_parent_ + gfx::Vector2d(dx, dy), 0);
   }
 
   void DragEnd() {
     resizer_->CompleteDrag();
     resizer_.reset();
   }
 
   void DragRevert() {
     resizer_->RevertDrag();
     resizer_.reset();
   }
 
   // Panels are parented by panel container during drags.
   // All other windows that are tested here are parented by dock container
   // during drags.
   int CorrectContainerIdDuringDrag() {
     if (window_type_ == ui::wm::WINDOW_TYPE_PANEL)
       return kShellWindowId_PanelContainer;
     return kShellWindowId_DockedContainer;
   }
 
   // Test dragging the window vertically (to detach if it is a panel) and then
   // horizontally to the edge with an added offset from the edge of |dx|.
-  void DragRelativeToEdge(DockedEdge edge,
-                          aura::Window* window,
-                          int dx) {
+  void DragRelativeToEdge(DockedEdge edge, aura::Window* window, int dx) {
     DragVerticallyAndRelativeToEdge(
-        edge,
-        window,
-        dx,
-        window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20,
-        25,
-        5);
+        edge, window, dx, window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20,
+        25, 5);
   }
 
   void DragToVerticalPositionAndToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int y) {
     DragToVerticalPositionRelativeToEdge(edge, window, 0, y);
   }
 
   void DragToVerticalPositionRelativeToEdge(DockedEdge edge,
                                             aura::Window* window,
                                             int dx,
                                             int y) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
-    DragVerticallyAndRelativeToEdge(edge,
-                                    window,
-                                    dx, y - initial_bounds.y(),
+    DragVerticallyAndRelativeToEdge(edge, window, dx, y - initial_bounds.y(),
                                     25, 5);
   }
 
   // Detach if our window is a panel, then drag it vertically by |dy| and
   // horizontally to the edge with an added offset from the edge of |dx|.
   void DragVerticallyAndRelativeToEdge(DockedEdge edge,
                                        aura::Window* window,
-                                       int dx, int dy,
-                                       int grab_x, int grab_y) {
+                                       int dx,
+                                       int dy,
+                                       int grab_x,
+                                       int grab_y) {
     gfx::Rect initial_bounds = window->GetBoundsInScreen();
     // avoid snap by clicking away from the border
-    ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(window,
-                                                              grab_x, grab_y));
+    ASSERT_NO_FATAL_FAILURE(
+        DragStartAtOffsetFromWindowOrigin(window, grab_x, grab_y));
 
     gfx::Rect work_area = display::Screen::GetScreen()
                               ->GetDisplayNearestWindow(window)
                               .work_area();
     gfx::Point initial_location_in_screen = initial_location_in_parent_;
     ::wm::ConvertPointToScreen(window->parent(), &initial_location_in_screen);
     // Drag the window left or right to the edge (or almost to it).
     if (edge == DOCKED_EDGE_LEFT)
       dx += work_area.x() - initial_location_in_screen.x();
     else if (edge == DOCKED_EDGE_RIGHT)
       dx += work_area.right() - 1 - initial_location_in_screen.x();
     DragMove(dx, dy);
     EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
     // Release the mouse and the panel should be attached to the dock.
     DragEnd();
 
     // x-coordinate can get adjusted by snapping or sticking.
     // y-coordinate could be changed by possible automatic layout if docked.
     if (window->parent()->id() != kShellWindowId_DockedContainer &&
         !wm::GetWindowState(window)->HasRestoreBounds()) {
       EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y());
     }
   }
 
   bool test_panels() const { return window_type_ == ui::wm::WINDOW_TYPE_PANEL; }
 
-  aura::test::TestWindowDelegate* delegate() {
-    return &delegate_;
-  }
+  aura::test::TestWindowDelegate* delegate() { return &delegate_; }
 
   const gfx::Point& initial_location_in_parent() const {
     return initial_location_in_parent_;
   }
 
  private:
   std::unique_ptr<WindowResizer> resizer_;
   ShelfModel* model_;
   ui::wm::WindowType window_type_;
   aura::test::TestWindowDelegate delegate_;
@@ skipping 41 matching lines @@
   if (!SupportsHostWindowResize())
     return;
 
   std::unique_ptr<aura::Window> window(
       CreateTestWindow(gfx::Rect(0, 0, 201, 201)));
   // Grabbing at 70px ensures that at least 30% of the window is in screen,
   // otherwise the window would be adjusted in
   // WorkspaceLayoutManager::AdjustWindowBoundsWhenAdded.
   const int kGrabOffsetX = 70;
   const int kUndershootBy = 1;
-  DragVerticallyAndRelativeToEdge(DOCKED_EDGE_RIGHT,
-                                  window.get(),
+  DragVerticallyAndRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(),
                                   -kUndershootBy, test_panels() ? -100 : 20,
                                   kGrabOffsetX, 5);
 
   // The window right should be past the screen edge but not docked.
   // Initial touch point is 70px to the right which helps to find where the edge
   // should be.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right() +
-            window->bounds().width() - kGrabOffsetX - kUndershootBy - 1,
+                window->bounds().width() - kGrabOffsetX - kUndershootBy - 1,
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Verifies a window can be dragged and attached to the dock.
 TEST_P(DockedWindowResizerTest, AttachLeftPrecise) {
   if (!SupportsHostWindowResize())
     return;
 
   std::unique_ptr<aura::Window> window(
@@ skipping 87 matching lines @@
 
   // The window should be docked at the right edge.
   // Its width should shrink to ideal width.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Try to detach by dragging left less than kSnapToDockDistance.
   // The window should stay docked.
-  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(), 10, 0));
+  ASSERT_NO_FATAL_FAILURE(
+      DragStartAtOffsetFromWindowOrigin(window.get(), 10, 0));
   DragMove(-4, -10);
   // Release the mouse and the window should be still attached to the dock.
   DragEnd();
 
   // The window should be still attached to the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Try to detach by dragging left by kSnapToDockDistance or more.
   // The window should get undocked.
   const int left_edge = window->bounds().x();
-  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(), 10, 0));
+  ASSERT_NO_FATAL_FAILURE(
+      DragStartAtOffsetFromWindowOrigin(window.get(), 10, 0));
   DragMove(-32, -10);
   // Release the mouse and the window should be no longer attached to the dock.
   DragEnd();
 
   // The window should be floating on the desktop again and moved to the left.
   EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Dock on the right side, and undock by dragging the right edge of the window
@@ skipping 10 matching lines @@
 
   // The window should be docked at the right edge.
   // Its width should shrink to ideal width.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Try to detach by dragging left less than kSnapToDockDistance.
   // The window should stay docked.
-  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(), ideal_width() - 10, 0));
+  ASSERT_NO_FATAL_FAILURE(
+      DragStartAtOffsetFromWindowOrigin(window.get(), ideal_width() - 10, 0));
   DragMove(-4, -10);
   // Release the mouse and the window should be still attached to the dock.
   DragEnd();
 
   // The window should be still attached to the right edge.
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
 
   // Try to detach by dragging left by kSnapToDockDistance or more.
   // The window should get undocked.
   const int left_edge = window->bounds().x();
-  ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(), ideal_width() - 10, 0));
+  ASSERT_NO_FATAL_FAILURE(
+      DragStartAtOffsetFromWindowOrigin(window.get(), ideal_width() - 10, 0));
   DragMove(-32, -10);
   // Release the mouse and the window should be no longer attached to the dock.
   DragEnd();
 
   // The window should be floating on the desktop again and moved to the left.
   EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 }
 
 // Minimize a docked window, then restore it and check that it is still docked.
@@ skipping 143 matching lines @@
   gfx::Rect initial_bounds(w2->bounds());
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w2.get(), 50);
 
   // The first window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be near the left edge but not snapped.
   // Normal window will get side-maximized while panels will not.
-  int expected_x = test_panels() ?
-      (initial_bounds.x() - initial_location_in_parent().x()) : 0;
+  int expected_x = test_panels()
+                       ? (initial_bounds.x() - initial_location_in_parent().x())
+                       : 0;
   EXPECT_EQ(expected_x, w2->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
 }
 
 // Tests that reverting a drag restores docked state if a window was docked.
 TEST_P(DockedWindowResizerTest, RevertDragRestoresAttachment) {
   if (!SupportsHostWindowResize())
     return;
 
   std::unique_ptr<aura::Window> window(
@@ skipping 30 matching lines @@
   // Drag the window out but revert the drag
   ASSERT_NO_FATAL_FAILURE(DragStart(window.get()));
   DragMove(-50 - window->bounds().x(), 50 - window->bounds().y());
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragRevert();
   EXPECT_EQ(previous_container_id, window->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
 
   // Drag a window to the left so that it overlaps the screen edge.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(),
-      window->bounds().width()/2 + 10,
-      0));
+      window.get(), window->bounds().width() / 2 + 10, 0));
   DragMove(-50 - window->bounds().x(), 50 - window->bounds().y());
   DragEnd();
   // The window now overlaps the left screen edge but is not docked.
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   EXPECT_LT(window->bounds().x(), 0);
   EXPECT_GT(window->bounds().right(), 0);
 
   // Drag the window further left and revert the drag.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(),
-      window->bounds().width()/2 + 10,
-      0));
+      window.get(), window->bounds().width() / 2 + 10, 0));
   DragMove(-10, 10);
   DragRevert();
   // The window should be in default container and not docked.
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   // Docked area alignment should be cleared.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
 }
 
 // Move a docked window to the second display
 TEST_P(DockedWindowResizerTest, DragAcrossDisplays) {
@@ skipping 22 matching lines @@
   DragEnd();
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 
   // Undock and move to the right - enough to get the mouse pointer past the
   // edge of the screen and into the second screen. The window should now be
   // in the second screen and not docked.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(),
-      window->bounds().width()/2 + 10,
-      0));
-  DragMove(window->bounds().width()/2 - 5, 0);
+      window.get(), window->bounds().width() / 2 + 10, 0));
+  DragMove(window->bounds().width() / 2 - 5, 0);
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragEnd();
   EXPECT_NE(window->GetRootWindow()->GetBoundsInScreen().right(),
             window->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 
   // Keep dragging it to the right until its left edge touches the screen edge.
   // The window should now be in the second screen and not docked.
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      window.get(),
-      window->bounds().width()/2 + 10,
-      0));
+      window.get(), window->bounds().width() / 2 + 10, 0));
   DragMove(window->GetRootWindow()->GetBoundsInScreen().x() -
-           window->GetBoundsInScreen().x(),
+               window->GetBoundsInScreen().x(),
            0);
   EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id());
   DragEnd();
   EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(),
             window->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 }
 
 // Dock two windows, undock one.
@@ skipping 45 matching lines @@
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be still docked.
   EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
 
   // Detach by dragging left more (should get undocked).
   const int left_edge = w2->bounds().x();
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(
-      w2.get(),
-      w2->bounds().width()/2 + 10,
-      0));
+      w2.get(), w2->bounds().width() / 2 + 10, 0));
   // Drag up as well to avoid attaching panels to launcher shelf.
-  const int drag_x = -(w2->bounds().width()/2 + 20);
+  const int drag_x = -(w2->bounds().width() / 2 + 20);
   DragMove(drag_x, -100);
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
 
   // The second window should be floating on the desktop again.
   EXPECT_EQ(left_edge + drag_x, w2->bounds().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to remaining single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
@@ skipping 15 matching lines @@
   // A window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 25, 5));
-  DragMove(w2->GetRootWindow()->bounds().width()
-           -w2->bounds().width()
-           -(w2->bounds().width()/2 + 20)
-           -w2->bounds().x(),
+  DragMove(w2->GetRootWindow()->bounds().width() - w2->bounds().width() -
+               (w2->bounds().width() / 2 + 20) - w2->bounds().x(),
            50 - w2->bounds().y());
   DragEnd();
   // The first window should be still docked.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
 
   // The second window should be floating on the desktop.
   EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right() -
-            (w2->bounds().width()/2 + 20),
+                (w2->bounds().width() / 2 + 20),
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to remaining single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should now shrink.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Maximize the second window - Maximized area should be shrunk.
   const gfx::Rect restored_bounds = w2->bounds();
   wm::WindowState* w2_state = wm::GetWindowState(w2.get());
   w2_state->Maximize();
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             w2->bounds().width());
 
   // Detach the first window (this should require very little drag).
   ASSERT_NO_FATAL_FAILURE(DragStart(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   DragMove(-35, 10);
   // Alignment is set to "NONE" when drag starts.
   EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager));
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
@@ skipping 17 matching lines @@
   // Release the mouse and the window should be now attached to the edge.
   DragEnd();
   // Dock should get expanded and desktop should get shrunk.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Second window should still be in the desktop.
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   // Maximized window should be shrunk.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             w2->bounds().width());
 
   // Unmaximize the second window.
   w2_state->Restore();
   // Its bounds should get restored.
   EXPECT_EQ(restored_bounds, w2->bounds());
 }
 
 // Dock one window. Test the sticky behavior near screen or desktop edge.
 TEST_P(DockedWindowResizerTest, AttachOneTestSticky) {
@@ skipping 15 matching lines @@
       DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   // The first window should be docked.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().x(),
             w1->GetBoundsInScreen().x());
   // Dock width should be set to that of a single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Position second window in the desktop 20px to the right of the docked w1.
-  DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT,
-                                       w2.get(),
-                                       20 + 25 -
-                                       min_dock_gap(),
-                                       50);
+  DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT, w2.get(),
+                                       20 + 25 - min_dock_gap(), 50);
   // The second window should be floating on the desktop.
   EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().x() +
                 (w1->bounds().right() + 20),
             w2->GetBoundsInScreen().x());
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   // Dock width should be set to that of a single docked window.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
@@ skipping 41 matching lines @@
   DragEnd();
   // Both windows are docked now.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock should get expanded and desktop should get shrunk.
   EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager));
   EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()),
             docked_width(manager));
   // Desktop work area should now shrink by dock width.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 }
 
 // Dock two windows, resize one.
 // Test the docked windows area size and remaining desktop resizing.
 TEST_P(DockedWindowResizerTest, ResizeOneOfTwoWindows) {
   if (!SupportsHostWindowResize())
     return;
 
   // Wider display to start since panels are limited to half the display width.
@@ skipping 20 matching lines @@
             w2->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock width should be set to a wider window.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()),
             docked_width(manager));
 
   // Resize the first window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 is now wider than before. The dock should expand and be as wide as w1.
   EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window left by more than the dock maximum width.
   // This should cause the window width to be restricted by maximum dock width.
   previous_width = w1->bounds().width();
   const int kResizeSpan2 = 250;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan2, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 is now as wide as the maximum dock width and the dock should get
   // resized to the maximum width.
   EXPECT_EQ(max_width(), w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window right to get it completely inside the docked area.
   previous_width = w1->bounds().width();
   const int kResizeSpan3 = 100;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(kResizeSpan3, 0);
   // Alignment set to "RIGHT" during the drag because dock has a window in it.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be docked.
   DragEnd();
   // Dock should still have both windows in it.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 should be narrower than before by the length of the drag.
   EXPECT_EQ(previous_width - kResizeSpan3, w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   // The dock should be as wide as w1 or w2.
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
   // Desktop work area should shrink.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width());
 
   // Resize the first window left to be overhang again.
   previous_width = w1->bounds().width();
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan3, 0);
   DragEnd();
   EXPECT_EQ(previous_width + kResizeSpan3, w1->bounds().width());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   // Docked area should be as wide as possible (maximum) and same as w1.
   EXPECT_EQ(max_width(), docked_width(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Undock the first window. Docked area should shrink to its ideal size.
   ASSERT_NO_FATAL_FAILURE(DragStart(w1.get()));
   // Drag up as well to avoid attaching panels to launcher shelf.
   DragMove(-(400 - 210), -100);
   // Alignment set to "RIGHT" since we have another window docked.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be no longer attached to the edge.
   DragEnd();
   EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id());
   // Dock should be as wide as w2 (and same as ideal width).
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(ideal_width(), docked_width(manager));
   EXPECT_EQ(w2->bounds().width(), docked_width(manager));
   // The second window should be still docked.
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Desktop work area should be inset.
   EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width() -
-            docked_width(manager) - min_dock_gap(),
+                docked_width(manager) - min_dock_gap(),
             ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width());
 }
 
 // Dock a window, resize it and test that undocking it restores the pre-docked
 // size.
 TEST_P(DockedWindowResizerTest, ResizingKeepsSize) {
   if (!SupportsHostWindowResize())
     return;
 
   // Wider display to start since panels are limited to half the display width.
   UpdateDisplay("1000x600");
   const gfx::Size original_size(201, 201);
   std::unique_ptr<aura::Window> w1(
       CreateTestWindow(gfx::Rect(gfx::Point(), original_size)));
 
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20);
   // Window should be docked at the right edge.
   EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(),
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Resize the window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   // Alignment stays "RIGHT" during the drag because the only docked window
   // is being resized.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // The window should get docked.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // w1 is now wider and the dock should expand to be as wide as w1.
@@ skipping 31 matching lines @@
             w1->GetBoundsInScreen().right());
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Resize the window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(
-      w1.get(), 0, 20, HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   // Normally alignment would be reset to "NONE" during the drag when there is
   // only a single window docked and it is being dragged. However because that
   // window is being resized rather than moved the alignment is not changed.
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   // Release the mouse and the window should be attached to the edge.
   DragEnd();
   // The window should stay docked.
   EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id());
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
@@ skipping 38 matching lines @@
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // Dock width should be set to ideal width.
   DockedWindowLayoutManager* manager =
       DockedWindowLayoutManager::Get(WmWindowAura::Get(w1.get()));
   EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager));
   EXPECT_EQ(ideal_width(), docked_width(manager));
 
   // Resize the first window left by a bit and test that the dock expands.
   int previous_width = w1->bounds().width();
   const int kResizeSpan1 = 30;
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   DragEnd();
   // w1 is now wider than before.
   EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width());
   // Both windows should get resized since they both don't have min/max size.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Resize the second window left by a bit more and test that the dock expands.
   previous_width = w2->bounds().width();
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w2.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w2.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   DragEnd();
   // w2 should get wider since it was resized by a user.
   EXPECT_EQ(previous_width + kResizeSpan1, w2->bounds().width());
   // w1 should stay as wide as w2 since both were flush with the dock edge.
   EXPECT_EQ(w2->bounds().width(), w1->bounds().width());
   EXPECT_EQ(w2->bounds().width(), docked_width(manager));
 
   // Undock w2 and then dock it back.
   DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_RIGHT, w2.get(), -400, 100);
   EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id());
   DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100);
   EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id());
   // w2 should become same width as w1.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 
   // Make w1 even wider.
-  ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(),
-                                                              0, 20,
-                                                              HTLEFT));
+  ASSERT_NO_FATAL_FAILURE(
+      ResizeStartAtOffsetFromWindowOrigin(w1.get(), 0, 20, HTLEFT));
   DragMove(-kResizeSpan1, 0);
   DragEnd();
   // Making w1 wider should make both windows wider since w2 no longer remembers
   // user width.
   EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
   EXPECT_EQ(w1->bounds().width(), docked_width(manager));
 }
 
 // Tests that dragging a window down to shelf attaches a panel but does not
 // attach a regular window.
@@ skipping 225 matching lines @@
   EXPECT_TRUE(window_state->IsMaximized());
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowResizerTest,
                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
                                         ui::wm::WINDOW_TYPE_PANEL));
 
 }  // namespace ash