clang-format all of //ash

ash/wm/workspace/workspace_window_resizer_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/common/wm/workspace/workspace_window_resizer.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 27 matching lines @@
 
 const int kRootHeight = 600;
 
 Shelf* GetShelf() {
   return Shelf::ForPrimaryDisplay();
 }
 
 // A simple window delegate that returns the specified min size.
 class TestWindowDelegate : public aura::test::TestWindowDelegate {
  public:
-  TestWindowDelegate() {
-  }
+  TestWindowDelegate() {}
   ~TestWindowDelegate() override {}
 
-  void set_min_size(const gfx::Size& size) {
-    min_size_ = size;
-  }
+  void set_min_size(const gfx::Size& size) { min_size_ = size; }
 
-  void set_max_size(const gfx::Size& size) {
-    max_size_ = size;
-  }
+  void set_max_size(const gfx::Size& size) { max_size_ = size; }
 
  private:
   // Overridden from aura::Test::TestWindowDelegate:
   gfx::Size GetMinimumSize() const override { return min_size_; }
 
   gfx::Size GetMaximumSize() const override { return max_size_; }
 
   gfx::Size min_size_;
   gfx::Size max_size_;
 
@@ skipping 68 matching lines @@
       if (*i == window_.get() || *i == window2_.get() || *i == window3_.get()) {
         if (!result.empty())
           result += " ";
         result += base::IntToString((*i)->id());
       }
     }
     return result;
   }
 
  protected:
-  WindowResizer* CreateResizerForTest(
-      aura::Window* window,
-      const gfx::Point& point_in_parent,
-      int window_component) {
+  WindowResizer* CreateResizerForTest(aura::Window* window,
+                                      const gfx::Point& point_in_parent,
+                                      int window_component) {
     WindowResizer* resizer =
         CreateWindowResizer(WmWindowAura::Get(window), point_in_parent,
                             window_component,
                             aura::client::WINDOW_MOVE_SOURCE_MOUSE)
             .release();
     workspace_resizer_ = WorkspaceWindowResizer::GetInstanceForTest();
     return resizer;
   }
   WorkspaceWindowResizer* CreateWorkspaceResizerForTest(
       aura::Window* window,
@@ skipping 19 matching lines @@
     location.set_y(location.y() + delta_y);
     return location;
   }
 
   std::vector<aura::Window*> empty_windows() const {
     return std::vector<aura::Window*>();
   }
 
   void InitTouchResizeWindow(const gfx::Rect& bounds, int window_component) {
     touch_resize_delegate_.set_window_component(window_component);
-    touch_resize_window_.reset(
-        CreateTestWindowInShellWithDelegate(&touch_resize_delegate_, 0,
-                                            bounds));
+    touch_resize_window_.reset(CreateTestWindowInShellWithDelegate(
+        &touch_resize_delegate_, 0, bounds));
   }
 
   TestWindowDelegate delegate_;
   TestWindowDelegate delegate2_;
   TestWindowDelegate delegate3_;
   TestWindowDelegate delegate4_;
   std::unique_ptr<aura::Window> window_;
   std::unique_ptr<aura::Window> window2_;
   std::unique_ptr<aura::Window> window3_;
   std::unique_ptr<aura::Window> window4_;
@@ skipping 36 matching lines @@
 
   // Revert and make sure everything moves back.
   resizer->Drag(CalculateDragPoint(*resizer, 800, 20), 0);
   resizer->RevertDrag();
   EXPECT_EQ("0,300 400x300", window_->bounds().ToString());
   EXPECT_EQ("400,200 100x200", window2_->bounds().ToString());
 }
 
 // Assertions around collapsing and expanding.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_Compress) {
-  window_->SetBounds(gfx::Rect(   0, 300, 400, 300));
+  window_->SetBounds(gfx::Rect(0, 300, 400, 300));
   window2_->SetBounds(gfx::Rect(400, 200, 100, 200));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the left, which should expand w2 and collapse w1.
   resizer->Drag(CalculateDragPoint(*resizer, -100, 10), 0);
@@ skipping 18 matching lines @@
 
   // Back to -100.
   resizer->Drag(CalculateDragPoint(*resizer, -100, 20), 0);
   EXPECT_EQ("0,300 300x300", window_->bounds().ToString());
   EXPECT_EQ("300,200 200x200", window2_->bounds().ToString());
 }
 
 // Assertions around attached window resize dragging from the right with 3
 // windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_3) {
-  window_->SetBounds(gfx::Rect( 100, 300, 200, 300));
+  window_->SetBounds(gfx::Rect(100, 300, 200, 300));
   window2_->SetBounds(gfx::Rect(300, 300, 150, 200));
   window3_->SetBounds(gfx::Rect(450, 300, 100, 200));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
@@ skipping 20 matching lines @@
   // Revert and make sure everything moves back.
   resizer->RevertDrag();
   EXPECT_EQ("100,300 200x300", window_->bounds().ToString());
   EXPECT_EQ("300,300 150x200", window2_->bounds().ToString());
   EXPECT_EQ("450,300 100x200", window3_->bounds().ToString());
 }
 
 // Assertions around attached window resizing (collapsing and expanding) with
 // 3 windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_RIGHT_3_Compress) {
-  window_->SetBounds(gfx::Rect( 100, 300, 200, 300));
+  window_->SetBounds(gfx::Rect(100, 300, 200, 300));
   window2_->SetBounds(gfx::Rect(300, 300, 200, 200));
   window3_->SetBounds(gfx::Rect(450, 300, 100, 200));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
@@ skipping 13 matching lines @@
 
   // 100 to the left again.
   resizer->Drag(CalculateDragPoint(*resizer, -100, -10), 0);
   EXPECT_EQ("100,300 100x300", window_->bounds().ToString());
   EXPECT_EQ("200,300 266x200", window2_->bounds().ToString());
   EXPECT_EQ("466,300 134x200", window3_->bounds().ToString());
 }
 
 // Assertions around collapsing and expanding from the bottom.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_Compress) {
-  window_->SetBounds(gfx::Rect(   0, 100, 400, 300));
+  window_->SetBounds(gfx::Rect(0, 100, 400, 300));
   window2_->SetBounds(gfx::Rect(400, 400, 100, 200));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTBOTTOM,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it up 100, which should expand w2 and collapse w1.
   resizer->Drag(CalculateDragPoint(*resizer, 10, -100), 0);
@@ skipping 13 matching lines @@
 
   // Back to -100.
   resizer->Drag(CalculateDragPoint(*resizer, 20, -100), 0);
   EXPECT_EQ("0,100 400x200", window_->bounds().ToString());
   EXPECT_EQ("400,300 100x300", window2_->bounds().ToString());
 }
 
 // Assertions around attached window resize dragging from the bottom with 2
 // windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_2) {
-  window_->SetBounds(gfx::Rect( 0,  50, 400, 200));
+  window_->SetBounds(gfx::Rect(0, 50, 400, 200));
   window2_->SetBounds(gfx::Rect(0, 250, 200, 100));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTBOTTOM,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 100 to the bottom, which should expand w1 and push w2.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 100), 0);
@@ skipping 25 matching lines @@
 #define MAYBE_AttachedResize_BOTTOM_3 AttachedResize_BOTTOM_3
 #endif
 
 // Assertions around attached window resize dragging from the bottom with 3
 // windows.
 TEST_F(WorkspaceWindowResizerTest, MAYBE_AttachedResize_BOTTOM_3) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
-  window_->SetBounds(gfx::Rect( 300, 100, 300, 200));
+  window_->SetBounds(gfx::Rect(300, 100, 300, 200));
   window2_->SetBounds(gfx::Rect(300, 300, 200, 150));
   window3_->SetBounds(gfx::Rect(300, 450, 200, 100));
   delegate2_.set_min_size(gfx::Size(50, 52));
   delegate3_.set_min_size(gfx::Size(50, 38));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTBOTTOM,
@@ skipping 20 matching lines @@
   // Revert and make sure everything moves back.
   resizer->RevertDrag();
   EXPECT_EQ("300,100 300x200", window_->bounds().ToString());
   EXPECT_EQ("300,300 200x150", window2_->bounds().ToString());
   EXPECT_EQ("300,450 200x100", window3_->bounds().ToString());
 }
 
 // Assertions around attached window resizing (collapsing and expanding) with
 // 3 windows.
 TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_3_Compress) {
-  window_->SetBounds(gfx::Rect(  0,   0, 200, 200));
+  window_->SetBounds(gfx::Rect(0, 0, 200, 200));
   window2_->SetBounds(gfx::Rect(10, 200, 200, 200));
   window3_->SetBounds(gfx::Rect(20, 400, 100, 100));
   delegate2_.set_min_size(gfx::Size(52, 50));
   delegate3_.set_min_size(gfx::Size(38, 50));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTBOTTOM,
@@ skipping 261 matching lines @@
     EXPECT_EQ(wm::WINDOW_STATE_TYPE_NORMAL, window_state->GetStateType());
     gfx::Rect expected_bounds(snapped_bounds);
     expected_bounds.Inset(0, 0, 0, 10);
     EXPECT_EQ(expected_bounds.ToString(), window_->bounds().ToString());
     EXPECT_FALSE(window_state->HasRestoreBounds());
   }
 }
 
 // Verifies windows are correctly restacked when reordering multiple windows.
 TEST_F(WorkspaceWindowResizerTest, RestackAttached) {
-  window_->SetBounds(gfx::Rect(   0, 0, 200, 300));
+  window_->SetBounds(gfx::Rect(0, 0, 200, 300));
   window2_->SetBounds(gfx::Rect(200, 0, 100, 200));
   window3_->SetBounds(gfx::Rect(300, 0, 100, 100));
 
   {
     std::vector<aura::Window*> windows;
     windows.push_back(window2_.get());
     std::unique_ptr<WorkspaceWindowResizer> resizer(
         CreateWorkspaceResizerForTest(window_.get(), gfx::Point(), HTRIGHT,
                                       aura::client::WINDOW_MOVE_SOURCE_MOUSE,
                                       windows));
@@ skipping 16 matching lines @@
     // Move it 100 to the right, which should expand w1 and push w2 and w3.
     resizer->Drag(CalculateDragPoint(*resizer, 100, -10), 0);
 
     // 2 should be topmost since it's initially the highest in the stack.
     EXPECT_EQ("2 3 1", WindowOrderAsString(window_->parent()));
   }
 }
 
 // Makes sure we don't allow dragging below the work area.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffBottom) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 10, 0));
 
   ASSERT_EQ(1, display::Screen::GetScreen()->GetNumDisplays());
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 400));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTCAPTION));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 600), 0);
   int expected_y =
       kRootHeight - WorkspaceWindowResizer::kMinOnscreenHeight - 10;
   EXPECT_EQ("100," + base::IntToString(expected_y) + " 300x400",
             window_->bounds().ToString());
 }
 
 // Makes sure we don't allow dragging on the work area with multidisplay.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffBottomWithMultiDisplay) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   ASSERT_EQ(2, display::Screen::GetScreen()->GetNumDisplays());
 
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 10, 0));
 
   // Positions the secondary display at the bottom the primary display.
   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
       test::CreateDisplayLayout(display::DisplayPlacement::BOTTOM, 0));
 
   {
     window_->SetBounds(gfx::Rect(100, 200, 300, 20));
     DCHECK_LT(window_->bounds().height(),
               WorkspaceWindowResizer::kMinOnscreenHeight);
     // Drag down avoiding dragging along the edge as that would side-snap.
     std::unique_ptr<WindowResizer> resizer(
         CreateResizerForTest(window_.get(), gfx::Point(10, 0), HTCAPTION));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 400), 0);
     int expected_y = kRootHeight - window_->bounds().height() - 10;
     // When the mouse cursor is in the primary display, the window cannot move
     // on non-work area but can get all the way towards the bottom,
     // restricted only by the window height.
     EXPECT_EQ("100," + base::IntToString(expected_y) + " 300x20",
               window_->bounds().ToString());
     // Revert the drag in order to not remember the restore bounds.
     resizer->RevertDrag();
   }
 
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 10, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 10, 0));
   {
     window_->SetBounds(gfx::Rect(100, 200, 300, 400));
     std::unique_ptr<WindowResizer> resizer(
         CreateResizerForTest(window_.get(), gfx::Point(10, 0), HTCAPTION));
     ASSERT_TRUE(resizer.get());
     // Drag down avoiding dragging along the edge as that would side-snap.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 400), 0);
     int expected_y =
         kRootHeight - WorkspaceWindowResizer::kMinOnscreenHeight - 10;
     // When the mouse cursor is in the primary display, the window cannot move
@@ skipping 12 matching lines @@
     resizer->Drag(CalculateDragPoint(*resizer, 0, 500), 0);
     // The window can move to the secondary display beyond non-work area of
     // the primary display.
     EXPECT_EQ("100,700 300x400", window_->bounds().ToString());
     resizer->CompleteDrag();
   }
 }
 
 // Makes sure we don't allow dragging off the top of the work area.
 TEST_F(WorkspaceWindowResizerTest, DontDragOffTop) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(10, 0, 0, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(10, 0, 0, 0));
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 400));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTCAPTION));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, -600), 0);
   EXPECT_EQ("100,10 300x400", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeBottomOutsideWorkArea) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
 
   window_->SetBounds(gfx::Rect(100, 200, 300, 380));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTTOP));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 8, 0), 0);
   EXPECT_EQ("100,200 300x380", window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideLeftWorkArea) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
   int left = ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()).x();
   int pixels_to_left_border = 50;
   int window_width = 300;
   int window_x = left - window_width + pixels_to_left_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
   std::unique_ptr<WindowResizer> resizer(CreateResizerForTest(
       window_.get(), gfx::Point(pixels_to_left_border, 0), HTRIGHT));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -window_width, 0), 0);
   EXPECT_EQ(base::IntToString(window_x) + ",100 " +
                 base::IntToString(wm::kMinimumOnScreenArea - window_x) + "x380",
             window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideRightWorkArea) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
-  int right = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      window_.get()).right();
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
+  int right =
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()).right();
   int pixels_to_right_border = 50;
   int window_width = 300;
   int window_x = right - pixels_to_right_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(window_x, 0), HTLEFT));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
   EXPECT_EQ(base::IntToString(right - wm::kMinimumOnScreenArea) + ",100 " +
                 base::IntToString(window_width - pixels_to_right_border +
                                   wm::kMinimumOnScreenArea) +
                 "x380",
             window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, ResizeWindowOutsideBottomWorkArea) {
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
-  int bottom = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      window_.get()).bottom();
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
+  int bottom =
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
   int delta_to_bottom = 50;
   int height = 380;
   window_->SetBounds(gfx::Rect(100, bottom - delta_to_bottom, 300, height));
   std::unique_ptr<WindowResizer> resizer(CreateResizerForTest(
       window_.get(), gfx::Point(0, bottom - delta_to_bottom), HTTOP));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, bottom), 0);
   EXPECT_EQ("100," + base::IntToString(bottom - wm::kMinimumOnScreenArea) +
                 " 300x" +
                 base::IntToString(height -
                                   (delta_to_bottom - wm::kMinimumOnScreenArea)),
             window_->bounds().ToString());
 }
 
 // Verifies that 'outside' check of the resizer take into account the extended
 // desktop in case of repositions.
 TEST_F(WorkspaceWindowResizerTest, DragWindowOutsideRightToSecondaryDisplay) {
   // Only primary display.  Changes the window position to fit within the
   // display.
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
-  int right = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      window_.get()).right();
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
+  int right =
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()).right();
   int pixels_to_right_border = 50;
   int window_width = 300;
   int window_x = right - pixels_to_right_border;
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(window_x, 0), HTCAPTION));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
   EXPECT_EQ(base::IntToString(right - wm::kMinimumOnScreenArea) + ",100 " +
                 base::IntToString(window_width) + "x380",
             window_->bounds().ToString());
 
   if (!SupportsMultipleDisplays())
     return;
 
   // With secondary display.  Operation itself is same but doesn't change
   // the position because the window is still within the secondary display.
   UpdateDisplay("1000x600,600x400");
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      Shell::GetPrimaryRootWindow(), gfx::Insets(0, 0, 50, 0));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(Shell::GetPrimaryRootWindow(),
+                                                 gfx::Insets(0, 0, 50, 0));
   window_->SetBounds(gfx::Rect(window_x, 100, window_width, 380));
   resizer->Drag(CalculateDragPoint(*resizer, window_width, 0), 0);
-  EXPECT_EQ(base::IntToString(window_x + window_width) +
-            ",100 " +
-            base::IntToString(window_width) +
-            "x380", window_->bounds().ToString());
+  EXPECT_EQ(base::IntToString(window_x + window_width) + ",100 " +
+                base::IntToString(window_width) + "x380",
+            window_->bounds().ToString());
 }
 
 // Verifies snapping to edges works.
 TEST_F(WorkspaceWindowResizerTest, SnapToEdge) {
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   window_->SetBounds(gfx::Rect(96, 112, 320, 160));
   // Click 50px to the right so that the mouse pointer does not leave the
   // workspace ensuring sticky behavior.
   std::unique_ptr<WindowResizer> resizer(CreateResizerForTest(
       window_.get(), window_->bounds().origin() + gfx::Vector2d(50, 0),
@@ skipping 35 matching lines @@
   resizer->Drag(CalculateDragPoint(*resizer, 0, 600 - 160 - 112 - 2 + 33), 0);
   EXPECT_EQ("96,471 320x160", window_->bounds().ToString());
 
   // And the top should snap too.
   resizer->Drag(CalculateDragPoint(*resizer, 0, -112 + 20), 0);
   EXPECT_EQ("96,20 320x160", window_->bounds().ToString());
   resizer->Drag(CalculateDragPoint(*resizer, 0, -112 + 7), 0);
   EXPECT_EQ("96,0 320x160", window_->bounds().ToString());
 
   // And bottom/left should snap too.
-  resizer->Drag(
-      CalculateDragPoint(*resizer, 7 - 96, 600 - 160 - 112 - 3 - 7), 0);
+  resizer->Drag(CalculateDragPoint(*resizer, 7 - 96, 600 - 160 - 112 - 3 - 7),
+                0);
   EXPECT_EQ("0,437 320x160", window_->bounds().ToString());
   resizer->Drag(
       CalculateDragPoint(*resizer, -15 - 96, 600 - 160 - 112 - 3 + 15), 0);
   EXPECT_EQ("0,437 320x160", window_->bounds().ToString());
   // should move past snap points.
   resizer->Drag(
       CalculateDragPoint(*resizer, -32 - 96, 600 - 160 - 112 - 2 + 32), 0);
   EXPECT_EQ("-32,470 320x160", window_->bounds().ToString());
   resizer->Drag(
       CalculateDragPoint(*resizer, -33 - 96, 600 - 160 - 112 - 2 + 33), 0);
   EXPECT_EQ("-33,471 320x160", window_->bounds().ToString());
 
   // No need to test dragging < 0 as we force that to 0.
 }
 
 // Verifies a resize snap when dragging TOPLEFT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTTOPLEFT));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, -98, -199), 0);
   EXPECT_EQ("0,0 120x230", window_->bounds().ToString());
 }
 
 // Verifies a resize snap when dragging TOPRIGHT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_TOPRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
-  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-                          window_.get()));
+  gfx::Rect work_area(
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTTOPRIGHT));
   ASSERT_TRUE(resizer.get());
-  resizer->Drag(
-      CalculateDragPoint(*resizer, work_area.right() - 120 - 1, -199), 0);
+  resizer->Drag(CalculateDragPoint(*resizer, work_area.right() - 120 - 1, -199),
+                0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(work_area.y(), window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(230, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMRIGHT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_BOTTOMRIGHT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
-  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-                          window_.get()));
+  gfx::Rect work_area(
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTBOTTOMRIGHT));
   ASSERT_TRUE(resizer.get());
-  resizer->Drag(
-      CalculateDragPoint(*resizer, work_area.right() - 120 - 1,
-                         work_area.bottom() - 220 - 2), 0);
+  resizer->Drag(CalculateDragPoint(*resizer, work_area.right() - 120 - 1,
+                                   work_area.bottom() - 220 - 2),
+                0);
   EXPECT_EQ(100, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(work_area.right() - 100, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 // Verifies a resize snap when dragging BOTTOMLEFT.
 TEST_F(WorkspaceWindowResizerTest, SnapToWorkArea_BOTTOMLEFT) {
   window_->SetBounds(gfx::Rect(100, 200, 20, 30));
-  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-                          window_.get()));
+  gfx::Rect work_area(
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()));
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTBOTTOMLEFT));
   ASSERT_TRUE(resizer.get());
-  resizer->Drag(
-      CalculateDragPoint(*resizer, -98, work_area.bottom() - 220 - 2), 0);
+  resizer->Drag(CalculateDragPoint(*resizer, -98, work_area.bottom() - 220 - 2),
+                0);
   EXPECT_EQ(0, window_->bounds().x());
   EXPECT_EQ(200, window_->bounds().y());
   EXPECT_EQ(120, window_->bounds().width());
   EXPECT_EQ(work_area.bottom() - 200, window_->bounds().height());
 }
 
 // Verifies window sticks to both window and work area.
 TEST_F(WorkspaceWindowResizerTest, StickToBothEdgeAndWindow) {
   window_->SetBounds(gfx::Rect(10, 10, 20, 50));
   window_->Show();
   window2_->SetBounds(gfx::Rect(150, 160, 25, 1000));
   window2_->Show();
 
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(10, 10), HTCAPTION));
   ASSERT_TRUE(resizer.get());
 
   // Move |window| one pixel to the left of |window2|. Should snap to right.
   resizer->Drag(CalculateDragPoint(*resizer, 119, 145), 0);
   gfx::Rect expected(130, 160, 20, 50);
   EXPECT_EQ(expected.ToString(), window_->bounds().ToString());
 
-  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-                          window_.get()));
+  gfx::Rect work_area(
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_.get()));
 
   // The initial y position of |window_|.
   int initial_y = 10;
   // The drag position where the window is exactly attached to the bottom.
   int attach_y = work_area.bottom() - window_->bounds().height() - initial_y;
 
   // Dragging 10px above should not attach to the bottom.
   resizer->Drag(CalculateDragPoint(*resizer, 119, attach_y - 10), 0);
   expected.set_y(attach_y + initial_y - 10);
   EXPECT_EQ(expected.ToString(), window_->bounds().ToString());
@@ skipping 254 matching lines @@
 
   std::unique_ptr<WindowResizer> resizer(
       CreateResizerForTest(window_.get(), gfx::Point(), HTLEFT));
   ASSERT_TRUE(resizer.get());
   resizer->Drag(CalculateDragPoint(*resizer, 0, 0), 0);
   EXPECT_EQ("99,200 21x30", window_->bounds().ToString());
 }
 
 // Test that the user user moved window flag is getting properly set.
 TEST_F(WorkspaceWindowResizerTest, CheckUserWindowManagedFlags) {
-  window_->SetBounds(gfx::Rect( 0,  50, 400, 200));
+  window_->SetBounds(gfx::Rect(0, 50, 400, 200));
   window_->SetProperty(aura::client::kCanMaximizeKey, true);
 
   std::vector<aura::Window*> no_attached_windows;
   // Check that an abort doesn't change anything.
   {
     std::unique_ptr<WindowResizer> resizer(
         CreateResizerForTest(window_.get(), gfx::Point(), HTCAPTION));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the bottom.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 100), 0);
@@ skipping 81 matching lines @@
     resizer->RevertDrag();
   }
 }
 
 TEST_F(WorkspaceWindowResizerTest, DontRewardRightmostWindowForOverflows) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Four 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   window4_->SetBounds(gfx::Rect(400, 100, 100, 100));
   delegate2_.set_max_size(gfx::Size(101, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
@@ skipping 10 matching lines @@
   EXPECT_EQ("250,100 125x100", window3_->bounds().ToString());
   EXPECT_EQ("375,100 125x100", window4_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, DontExceedMaxWidth) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Four 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   window4_->SetBounds(gfx::Rect(400, 100, 100, 100));
   delegate2_.set_max_size(gfx::Size(101, 0));
   delegate3_.set_max_size(gfx::Size(101, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 52 to the left, which should contract w1 and expand w2-4.
   resizer->Drag(CalculateDragPoint(*resizer, -52, 0), 0);
   EXPECT_EQ("100,100 48x100", window_->bounds().ToString());
   EXPECT_EQ("148,100 101x100", window2_->bounds().ToString());
   EXPECT_EQ("249,100 101x100", window3_->bounds().ToString());
   EXPECT_EQ("350,100 150x100", window4_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, DontExceedMaxHeight) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Four 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(100, 200, 100, 100));
   window3_->SetBounds(gfx::Rect(100, 300, 100, 100));
   window4_->SetBounds(gfx::Rect(100, 400, 100, 100));
   delegate2_.set_max_size(gfx::Size(0, 101));
   delegate3_.set_max_size(gfx::Size(0, 101));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
@@ skipping 15 matching lines @@
 #else
 #define MAYBE_DontExceedMinHeight DontExceedMinHeight
 #endif
 
 TEST_F(WorkspaceWindowResizerTest, MAYBE_DontExceedMinHeight) {
   UpdateDisplay("600x500");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Four 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(100, 200, 100, 100));
   window3_->SetBounds(gfx::Rect(100, 300, 100, 100));
   window4_->SetBounds(gfx::Rect(100, 400, 100, 100));
   delegate2_.set_min_size(gfx::Size(0, 99));
   delegate3_.set_min_size(gfx::Size(0, 99));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTBOTTOM,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 52 down, which should expand w1 and contract w2-4.
   resizer->Drag(CalculateDragPoint(*resizer, 0, 52), 0);
   EXPECT_EQ("100,100 100x152", window_->bounds().ToString());
   EXPECT_EQ("100,252 100x99", window2_->bounds().ToString());
   EXPECT_EQ("100,351 100x99", window3_->bounds().ToString());
   EXPECT_EQ("100,450 100x50", window4_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, DontExpandRightmostPastMaxWidth) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Three 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   delegate3_.set_max_size(gfx::Size(101, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 51 to the left, which should contract w1 and expand w2-3.
   resizer->Drag(CalculateDragPoint(*resizer, -51, 0), 0);
   EXPECT_EQ("100,100 49x100", window_->bounds().ToString());
   EXPECT_EQ("149,100 150x100", window2_->bounds().ToString());
   EXPECT_EQ("299,100 101x100", window3_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, MoveAttachedWhenGrownToMaxSize) {
   UpdateDisplay("600x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Three 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   delegate2_.set_max_size(gfx::Size(101, 0));
   delegate3_.set_max_size(gfx::Size(101, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
@@ skipping 13 matching lines @@
 #else
 #define MAYBE_MainWindowHonoursMaxWidth MainWindowHonoursMaxWidth
 #endif
 
 TEST_F(WorkspaceWindowResizerTest, MAYBE_MainWindowHonoursMaxWidth) {
   UpdateDisplay("400x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Three 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   delegate_.set_max_size(gfx::Size(102, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   windows.push_back(window4_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
   ASSERT_TRUE(resizer.get());
   // Move it 50 to the right, which should expand w1 and contract w2-3, as they
   // won't fit in the root window in their original sizes.
   resizer->Drag(CalculateDragPoint(*resizer, 50, 0), 0);
   EXPECT_EQ("100,100 102x100", window_->bounds().ToString());
   EXPECT_EQ("202,100 99x100", window2_->bounds().ToString());
   EXPECT_EQ("301,100 99x100", window3_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, MainWindowHonoursMinWidth) {
   UpdateDisplay("400x800");
   aura::Window* root = Shell::GetPrimaryRootWindow();
   Shell::GetInstance()->SetDisplayWorkAreaInsets(root, gfx::Insets());
 
   // Three 100x100 windows flush against eachother, starting at 100,100.
-  window_->SetBounds(gfx::Rect( 100, 100, 100, 100));
+  window_->SetBounds(gfx::Rect(100, 100, 100, 100));
   window2_->SetBounds(gfx::Rect(200, 100, 100, 100));
   window3_->SetBounds(gfx::Rect(300, 100, 100, 100));
   delegate_.set_min_size(gfx::Size(98, 0));
 
   std::vector<aura::Window*> windows;
   windows.push_back(window2_.get());
   windows.push_back(window3_.get());
   std::unique_ptr<WorkspaceWindowResizer> resizer(CreateWorkspaceResizerForTest(
       window_.get(), gfx::Point(), HTRIGHT,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, windows));
@@ skipping 14 matching lines @@
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      touch_resize_window_.get());
 
   // Drag out of the right border a bit and check if the border is aligned with
   // the touch point.
   generator.GestureScrollSequence(gfx::Point(715, kRootHeight / 2),
                                   gfx::Point(725, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 625, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag more, but stop before being snapped to the edge.
   generator.GestureScrollSequence(gfx::Point(725, kRootHeight / 2),
                                   gfx::Point(760, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 660, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag even more to snap to the edge.
   generator.GestureScrollSequence(gfx::Point(760, kRootHeight / 2),
                                   gfx::Point(775, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 700, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, TouchResizeToEdge_LEFT) {
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
 
   InitTouchResizeWindow(gfx::Rect(100, 100, 600, kRootHeight - 200), HTLEFT);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      touch_resize_window_.get());
 
   // Drag out of the left border a bit and check if the border is aligned with
   // the touch point.
   generator.GestureScrollSequence(gfx::Point(85, kRootHeight / 2),
                                   gfx::Point(75, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(75, 100, 625, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag more, but stop before being snapped to the edge.
   generator.GestureScrollSequence(gfx::Point(75, kRootHeight / 2),
                                   gfx::Point(40, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(40, 100, 660, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag even more to snap to the edge.
   generator.GestureScrollSequence(gfx::Point(40, kRootHeight / 2),
                                   gfx::Point(25, kRootHeight / 2),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(0, 100, 700, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, TouchResizeToEdge_TOP) {
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
 
   InitTouchResizeWindow(gfx::Rect(100, 100, 600, kRootHeight - 200), HTTOP);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      touch_resize_window_.get());
 
   // Drag out of the top border a bit and check if the border is aligned with
   // the touch point.
-  generator.GestureScrollSequence(gfx::Point(400, 85),
-                                  gfx::Point(400, 75),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+  generator.GestureScrollSequence(gfx::Point(400, 85), gfx::Point(400, 75),
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 75, 600, kRootHeight - 175).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag more, but stop before being snapped to the edge.
-  generator.GestureScrollSequence(gfx::Point(400, 75),
-                                  gfx::Point(400, 40),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+  generator.GestureScrollSequence(gfx::Point(400, 75), gfx::Point(400, 40),
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 40, 600, kRootHeight - 140).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag even more to snap to the edge.
-  generator.GestureScrollSequence(gfx::Point(400, 40),
-                                  gfx::Point(400, 25),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+  generator.GestureScrollSequence(gfx::Point(400, 40), gfx::Point(400, 25),
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 0, 600, kRootHeight - 100).ToString(),
             touch_resize_window_->bounds().ToString());
 }
 
 TEST_F(WorkspaceWindowResizerTest, TouchResizeToEdge_BOTTOM) {
   GetShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
 
   InitTouchResizeWindow(gfx::Rect(100, 100, 600, kRootHeight - 200), HTBOTTOM);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 200).ToString(),
             touch_resize_window_->bounds().ToString());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      touch_resize_window_.get());
 
   // Drag out of the bottom border a bit and check if the border is aligned with
   // the touch point.
   generator.GestureScrollSequence(gfx::Point(400, kRootHeight - 85),
                                   gfx::Point(400, kRootHeight - 75),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 175).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag more, but stop before being snapped to the edge.
   generator.GestureScrollSequence(gfx::Point(400, kRootHeight - 75),
                                   gfx::Point(400, kRootHeight - 40),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 140).ToString(),
             touch_resize_window_->bounds().ToString());
   // Drag even more to snap to the edge.
   generator.GestureScrollSequence(gfx::Point(400, kRootHeight - 40),
                                   gfx::Point(400, kRootHeight - 25),
-                                  base::TimeDelta::FromMilliseconds(10),
-                                  5);
+                                  base::TimeDelta::FromMilliseconds(10), 5);
   EXPECT_EQ(gfx::Rect(100, 100, 600, kRootHeight - 100).ToString(),
             touch_resize_window_->bounds().ToString());
 }
 
 }  // namespace ash