clang-format all of //ash

ash/wm/workspace_controller_unittest.cc

 // Copyright 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/wm/workspace_controller.h"
 
 #include <map>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
@@ skipping 52 matching lines @@
   typedef std::map<const ui::Layer*, std::string> LayerToWindowNameMap;
   LayerToWindowNameMap window_names;
   for (size_t i = 0; i < window->children().size(); ++i) {
     window_names[window->children()[i]->layer()] =
         window->children()[i]->name();
   }
 
   std::string result;
   const std::vector<ui::Layer*>& layers(window->layer()->children());
   for (size_t i = 0; i < layers.size(); ++i) {
-    LayerToWindowNameMap::iterator layer_i =
-        window_names.find(layers[i]);
+    LayerToWindowNameMap::iterator layer_i = window_names.find(layers[i]);
     if (layer_i != window_names.end()) {
       if (!result.empty())
         result += " ";
       result += layer_i->second;
     }
   }
   return result;
 }
 
 class WorkspaceControllerTest : public test::AshTestBase {
@@ skipping 29 matching lines @@
 
   aura::Window* CreatePopupLikeWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithBounds(bounds);
     window->Show();
     return window;
   }
 
   aura::Window* CreateTestPanel(aura::WindowDelegate* delegate,
                                 const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
-        delegate,
-        ui::wm::WINDOW_TYPE_PANEL,
-        0,
-        bounds);
+        delegate, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
     test::TestShelfDelegate* shelf_delegate =
         test::TestShelfDelegate::instance();
     shelf_delegate->AddShelfItem(window);
     PanelLayoutManager* manager =
         PanelLayoutManager::Get(WmWindowAura::Get(window));
     manager->Relayout();
     return window;
   }
 
   aura::Window* GetDesktop() {
@@ skipping 89 matching lines @@
 
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Both windows should be in the same workspace.
   EXPECT_EQ(w1.get(), GetDesktop()->children()[0]);
   EXPECT_EQ(w2.get(), GetDesktop()->children()[1]);
 
-  gfx::Rect work_area(
-      ScreenUtil::GetMaximizedWindowBoundsInParent(w1.get()));
+  gfx::Rect work_area(ScreenUtil::GetMaximizedWindowBoundsInParent(w1.get()));
   EXPECT_EQ(work_area.width(), w2->bounds().width());
   EXPECT_EQ(work_area.height(), w2->bounds().height());
 
   // Restore w2, which should then go back to one workspace.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(50, w2->bounds().width());
   EXPECT_EQ(51, w2->bounds().height());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 }
 
@@ skipping 208 matching lines @@
 
   // Create another window, maximized.
   std::unique_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
-  EXPECT_EQ(ScreenUtil::GetMaximizedWindowBoundsInParent(
-                w2->parent()).ToString(),
-            w2->bounds().ToString());
+  EXPECT_EQ(
+      ScreenUtil::GetMaximizedWindowBoundsInParent(w2->parent()).ToString(),
+      w2->bounds().ToString());
 
   // Switch to w1.
   wm::ActivateWindow(w1.get());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
-  EXPECT_EQ(ScreenUtil::GetMaximizedWindowBoundsInParent(
-                w2->parent()).ToString(),
-            w2->bounds().ToString());
+  EXPECT_EQ(
+      ScreenUtil::GetMaximizedWindowBoundsInParent(w2->parent()).ToString(),
+      w2->bounds().ToString());
 
   // Switch to w2.
   wm::ActivateWindow(w2.get());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
   EXPECT_EQ(ScreenUtil::GetMaximizedWindowBoundsInParent(w2.get()).ToString(),
             w2->bounds().ToString());
 
   // Turn off auto-hide, switch back to w2 (maximized) and verify overlap.
@@ skipping 211 matching lines @@
 TEST_F(WorkspaceControllerTest, TransientParent) {
   // Normal window with no transient parent.
   std::unique_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->Show();
   wm::ActivateWindow(w2.get());
 
   // Window with a transient parent. We set the transient parent to the root,
   // which would never happen but is enough to exercise the bug.
   std::unique_ptr<Window> w1(CreateTestWindowUnparented());
-  ::wm::AddTransientChild(
-      Shell::GetInstance()->GetPrimaryRootWindow(), w1.get());
+  ::wm::AddTransientChild(Shell::GetInstance()->GetPrimaryRootWindow(),
+                          w1.get());
   w1->SetBounds(gfx::Rect(10, 11, 250, 251));
   ParentWindowInPrimaryRootWindow(w1.get());
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   // The window with the transient parent should get added to the same parent as
   // the normal window.
   EXPECT_EQ(w2->parent(), w1->parent());
 }
 
 // Test the placement of newly created windows.
 TEST_F(WorkspaceControllerTest, BasicAutoPlacingOnCreate) {
   if (!SupportsHostWindowResize())
     return;
   UpdateDisplay("1600x1200");
   // Creating a popup handler here to make sure it does not interfere with the
   // existing windows.
   gfx::Rect source_browser_bounds(16, 32, 640, 320);
   std::unique_ptr<aura::Window> browser_window(
       CreateBrowserLikeWindow(source_browser_bounds));
 
   // Creating a popup to make sure it does not interfere with the positioning.
   std::unique_ptr<aura::Window> browser_popup(
       CreatePopupLikeWindow(gfx::Rect(16, 32, 128, 256)));
 
   browser_window->Show();
   browser_popup->Show();
 
-  { // With a shown window it's size should get returned.
+  {  // With a shown window it's size should get returned.
     std::unique_ptr<aura::Window> new_browser_window(
         CreateBrowserLikeWindow(source_browser_bounds));
     // The position should be right flush.
     EXPECT_EQ("960,32 640x320", new_browser_window->bounds().ToString());
   }
 
-  { // With the window shown - but more on the right side then on the left
+  {  // With the window shown - but more on the right side then on the left
     // side (and partially out of the screen), it should default to the other
     // side and inside the screen.
     gfx::Rect source_browser_bounds(gfx::Rect(1000, 600, 640, 320));
     browser_window->SetBounds(source_browser_bounds);
 
     std::unique_ptr<aura::Window> new_browser_window(
         CreateBrowserLikeWindow(source_browser_bounds));
     // The position should be left & bottom flush.
     EXPECT_EQ("0,600 640x320", new_browser_window->bounds().ToString());
 
     // If the other window was already beyond the point to get right flush
     // it will remain where it is.
     EXPECT_EQ("1000,600 640x320", browser_window->bounds().ToString());
   }
 
-  { // Make sure that popups do not get changed.
+  {  // Make sure that popups do not get changed.
     std::unique_ptr<aura::Window> new_popup_window(
         CreatePopupLikeWindow(gfx::Rect(50, 100, 300, 150)));
     EXPECT_EQ("50,100 300x150", new_popup_window->bounds().ToString());
   }
 
   browser_window->Hide();
-  { // If a window is there but not shown the default should be centered.
+  {  // If a window is there but not shown the default should be centered.
     std::unique_ptr<aura::Window> new_browser_window(
         CreateBrowserLikeWindow(gfx::Rect(50, 100, 300, 150)));
     EXPECT_EQ("650,100 300x150", new_browser_window->bounds().ToString());
   }
 }
 
 // Test that adding a second window shifts both the first window and its
 // transient child.
 TEST_F(WorkspaceControllerTest, AutoPlacingMovesTransientChild) {
   // Create an auto-positioned window.
@@ skipping 72 matching lines @@
 
   std::unique_ptr<aura::Window> window3(CreateTestWindowInShellWithId(2));
   wm::GetWindowState(window3.get())->set_window_position_managed(true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window3->Hide();
   window3->SetBounds(gfx::Rect(32, 48, 256, 512));
   window3->Show();
   // |window1| should be flush left and |window3| flush right.
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window3->bounds().width()) +
-            ",48 256x512", window3->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window3->bounds().width()) +
+          ",48 256x512",
+      window3->bounds().ToString());
 
   // After removing |window3|, |window1| should be centered again.
   window3.reset();
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(base::IntToString(
+                (desktop_area.width() - window1->bounds().width()) / 2) +
+                ",32 640x320",
+            window1->bounds().ToString());
 
   // Test 3: Set up a manageable and a non manageable window and check
   // positioning.
   std::unique_ptr<aura::Window> window4(CreateTestWindowInShellWithId(3));
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   window4->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Show();
   // |window1| should be centered and |window4| untouched.
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(base::IntToString(
+                (desktop_area.width() - window1->bounds().width()) / 2) +
+                ",32 640x320",
+            window1->bounds().ToString());
   EXPECT_EQ("32,48 256x512", window4->bounds().ToString());
 
   // Test4: A single manageable window should get centered.
   window4.reset();
   window1_state->set_bounds_changed_by_user(false);
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
   // |window1| should be centered.
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(base::IntToString(
+                (desktop_area.width() - window1->bounds().width()) / 2) +
+                ",32 640x320",
+            window1->bounds().ToString());
 }
 
 // Test the proper usage of user window movement interaction.
 TEST_F(WorkspaceControllerTest, TestUserMovedWindowRepositioning) {
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
@@ skipping 16 matching lines @@
   EXPECT_FALSE(window2_state->bounds_changed_by_user());
 
   // Turn on the second window and make sure that both windows are now
   // positionable again (user movement cleared).
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
-      ",48 256x512", window2->bounds().ToString());
+          ",48 256x512",
+      window2->bounds().ToString());
   // FLag should now be reset.
   EXPECT_FALSE(window1_state->bounds_changed_by_user());
   EXPECT_FALSE(window2_state->bounds_changed_by_user());
 
   // Going back to one shown window should keep the state.
   window1_state->set_bounds_changed_by_user(true);
   window2->Hide();
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_TRUE(window1_state->bounds_changed_by_user());
 }
@@ skipping 62 matching lines @@
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
   wm::GetWindowState(window1.get())->set_window_position_managed(true);
   wm::GetWindowState(window2.get())->set_window_position_managed(true);
   window1->Show();
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
-  EXPECT_EQ("0," + base::IntToString(user_pos.y()) +
-            " 640x320", window1->bounds().ToString());
+  EXPECT_EQ("0," + base::IntToString(user_pos.y()) + " 640x320",
+            window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
-      ",48 256x512", window2->bounds().ToString());
+          ",48 256x512",
+      window2->bounds().ToString());
   window2->Hide();
 
   // After the other window get hidden the window has to move back to the
   // previous position and the bounds should still be set and unchanged.
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
   ASSERT_TRUE(window1_state->pre_auto_manage_window_bounds());
   EXPECT_EQ(user_pos.ToString(),
             window1_state->pre_auto_manage_window_bounds()->ToString());
 }
 
@@ skipping 62 matching lines @@
   window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(window2_state->IsNormalStateType());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",48 256x512", window2->bounds().ToString());
+                ",48 256x512",
+            window2->bounds().ToString());
 
   window1_state->Restore();
   // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window1->bounds().width()) +
+          ",32 640x320",
+      window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // Test that minimizing an initially maximized window will repos the remaining.
 TEST_F(WorkspaceControllerTest, MaxToMinRepositionsRemaining) {
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   wm::WindowState* window2_state = wm::GetWindowState(window2.get());
   window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
   window1_state->Maximize();
   window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(window2_state->IsNormalStateType());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",48 256x512", window2->bounds().ToString());
+                ",48 256x512",
+            window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, minimizing will repos the remaining.
 TEST_F(WorkspaceControllerTest, NormToMaxToMinRepositionsRemaining) {
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   wm::WindowState* window2_state = wm::GetWindowState(window2.get());
   window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window1->bounds().width()) +
+          ",32 640x320",
+      window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
   window1_state->Maximize();
   window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
   EXPECT_TRUE(window2_state->IsNormalStateType());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",40 256x512", window2->bounds().ToString());
+                ",40 256x512",
+            window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, normal will repos the remaining.
 TEST_F(WorkspaceControllerTest, NormToMaxToNormRepositionsRemaining) {
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   std::unique_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   wm::GetWindowState(window2.get())->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window1->bounds().width()) +
+          ",32 640x320",
+      window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
   window1_state->Maximize();
   window1_state->Restore();
 
   // |window1| should be flush right and |window2| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window1->bounds().width()) +
+          ",32 640x320",
+      window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 }
 
 // Test that animations are triggered.
 TEST_F(WorkspaceControllerTest, AnimatedNormToMaxToNormRepositionsRemaining) {
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
   std::unique_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
@@ skipping 14 matching lines @@
   EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
   window2->layer()->GetAnimator()->StopAnimating();
 
   window1->Show();
   EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
   EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
 
   window1->layer()->GetAnimator()->StopAnimating();
   window2->layer()->GetAnimator()->StopAnimating();
   // |window1| should be flush right and |window2| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
+  EXPECT_EQ(
+      base::IntToString(desktop_area.width() - window1->bounds().width()) +
+          ",32 640x320",
+      window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // This tests simulates a browser and an app and verifies the ordering of the
 // windows and layers doesn't get out of sync as various operations occur. Its
 // really testing code in FocusController, but easier to simulate here. Just as
 // with a real browser the browser here has a transient child window
 // (corresponds to the status bubble).
 TEST_F(WorkspaceControllerTest, VerifyLayerOrdering) {
   std::unique_ptr<Window> browser(aura::test::CreateTestWindowWithDelegate(
       NULL, ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(5, 6, 7, 8), NULL));
   browser->SetName("browser");
   ParentWindowInPrimaryRootWindow(browser.get());
   browser->Show();
   wm::ActivateWindow(browser.get());
 
   // |status_bubble| is made a transient child of |browser| and as a result
   // owned by |browser|.
   aura::test::TestWindowDelegate* status_bubble_delegate =
       aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate();
   status_bubble_delegate->set_can_focus(false);
-  Window* status_bubble =
-      aura::test::CreateTestWindowWithDelegate(status_bubble_delegate,
-                                               ui::wm::WINDOW_TYPE_POPUP,
-                                               gfx::Rect(5, 6, 7, 8),
-                                               NULL);
+  Window* status_bubble = aura::test::CreateTestWindowWithDelegate(
+      status_bubble_delegate, ui::wm::WINDOW_TYPE_POPUP, gfx::Rect(5, 6, 7, 8),
+      NULL);
   ::wm::AddTransientChild(browser.get(), status_bubble);
   ParentWindowInPrimaryRootWindow(status_bubble);
   status_bubble->SetName("status_bubble");
 
   std::unique_ptr<Window> app(aura::test::CreateTestWindowWithDelegate(
       NULL, ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(5, 6, 7, 8), NULL));
   app->SetName("app");
   ParentWindowInPrimaryRootWindow(app.get());
 
   aura::Window* parent = browser->parent();
@@ skipping 31 matching lines @@
   // Activate the app.
   ash::wm::ActivateWindow(app.get());
   EXPECT_TRUE(wm::IsActiveWindow(app.get()));
   EXPECT_EQ(GetWindowNames(parent), GetLayerNames(parent));
 }
 
 namespace {
 
 // Used by DragMaximizedNonTrackedWindow to track how many times the window
 // hierarchy changes affecting the specified window.
-class DragMaximizedNonTrackedWindowObserver
-    : public aura::WindowObserver {
+class DragMaximizedNonTrackedWindowObserver : public aura::WindowObserver {
  public:
   DragMaximizedNonTrackedWindowObserver(aura::Window* window)
-  : change_count_(0),
-    window_(window) {
-  }
+      : change_count_(0), window_(window) {}
 
   // Number of times OnWindowHierarchyChanged() has been received.
   void clear_change_count() { change_count_ = 0; }
-  int change_count() const {
-    return change_count_;
-  }
+  int change_count() const { return change_count_; }
 
   // aura::WindowObserver overrides:
   // Counts number of times a window is reparented. Ignores reparenting into and
   // from a docked container which is expected when a tab is dragged.
   void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override {
     if (params.target != window_ ||
         (params.old_parent->id() == kShellWindowId_DefaultContainer &&
          params.new_parent->id() == kShellWindowId_DockedContainer) ||
         (params.old_parent->id() == kShellWindowId_DockedContainer &&
          params.new_parent->id() == kShellWindowId_DefaultContainer)) {
@@ skipping 16 matching lines @@
 // modal window is active.
 TEST_F(WorkspaceControllerTest, SwitchFromModal) {
   std::unique_ptr<Window> modal_window(CreateTestWindowUnparented());
   modal_window->SetBounds(gfx::Rect(10, 11, 21, 22));
   modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
   ParentWindowInPrimaryRootWindow(modal_window.get());
   modal_window->Show();
   wm::ActivateWindow(modal_window.get());
 
   std::unique_ptr<Window> maximized_window(CreateTestWindow());
-  maximized_window->SetProperty(
-      aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
+  maximized_window->SetProperty(aura::client::kShowStateKey,
+                                ui::SHOW_STATE_MAXIMIZED);
   maximized_window->Show();
   wm::ActivateWindow(maximized_window.get());
   EXPECT_TRUE(maximized_window->IsVisible());
 }
 
 namespace {
 
 // Subclass of WorkspaceControllerTest that runs tests with docked windows
 // enabled and disabled.
 class WorkspaceControllerTestDragging : public WorkspaceControllerTest {
@@ skipping 81 matching lines @@
 
   // The windows overlap, and |second| is on top of |first|. Events targeted
   // slightly outside the edges of the |second| window should still be targeted
   // to |second| to allow resizing the windows easily.
 
   const int kNumPoints = 4;
   struct {
     const char* direction;
     gfx::Point location;
   } points[kNumPoints] = {
-    { "left", gfx::Point(28, 45) },  // outside the left edge.
-    { "top", gfx::Point(50, 38) },  // outside the top edge.
-    { "right", gfx::Point(72, 45) },  // outside the right edge.
-    { "bottom", gfx::Point(50, 52) },  // outside the bottom edge.
+      {"left", gfx::Point(28, 45)},    // outside the left edge.
+      {"top", gfx::Point(50, 38)},     // outside the top edge.
+      {"right", gfx::Point(72, 45)},   // outside the right edge.
+      {"bottom", gfx::Point(50, 52)},  // outside the bottom edge.
   };
   // Do two iterations, first without any transform on |second|, and the second
   // time after applying some transform on |second| so that it doesn't get
   // targeted.
   for (int times = 0; times < 2; ++times) {
     SCOPED_TRACE(times == 0 ? "Without transform" : "With transform");
     aura::Window* expected_target = times == 0 ? second.get() : first.get();
     for (int i = 0; i < kNumPoints; ++i) {
       SCOPED_TRACE(points[i].direction);
       const gfx::Point& location = points[i].location;
@@ skipping 22 matching lines @@
       CreateTestPanel(&delegate, gfx::Rect(20, 10, 100, 50)));
   ui::EventTarget* root = window->GetRootWindow();
   ui::EventTargeter* targeter = root->GetEventTargeter();
   const gfx::Rect bounds = window->bounds();
   const int kNumPoints = 5;
   struct {
     const char* direction;
     gfx::Point location;
     bool is_target_hit;
   } points[kNumPoints] = {
-    { "left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true },
-    { "top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true },
-    { "right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true },
-    { "bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), true },
-    { "outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false },
+      {"left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true},
+      {"top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true},
+      {"right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true},
+      {"bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), true},
+      {"outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false},
   };
   for (int i = 0; i < kNumPoints; ++i) {
     SCOPED_TRACE(points[i].direction);
     const gfx::Point& location = points[i].location;
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, location, location,
                          ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &mouse);
     if (points[i].is_target_hit)
       EXPECT_EQ(window.get(), target);
     else
@@ skipping 11 matching lines @@
       CreateTestPanel(&delegate, gfx::Rect(20, 10, 100, 50)));
   ui::EventTarget* root = window->GetRootWindow();
   ui::EventTargeter* targeter = root->GetEventTargeter();
   const gfx::Rect bounds = window->bounds();
   const int kNumPoints = 5;
   struct {
     const char* direction;
     gfx::Point location;
     bool is_target_hit;
   } points[kNumPoints] = {
-    { "left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true },
-    { "top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true },
-    { "right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true },
-    { "bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), false },
-    { "outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false },
+      {"left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true},
+      {"top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true},
+      {"right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true},
+      {"bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), false},
+      {"outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false},
   };
   for (int i = 0; i < kNumPoints; ++i) {
     SCOPED_TRACE(points[i].direction);
     const gfx::Point& location = points[i].location;
     ui::TouchEvent touch(ui::ET_TOUCH_PRESSED, location, 0,
                          ui::EventTimeForNow());
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &touch);
     if (points[i].is_target_hit)
       EXPECT_EQ(window.get(), target);
     else
@@ skipping 16 matching lines @@
   window->Show();
   ui::EventTarget* root = window->GetRootWindow();
   ui::EventTargeter* targeter = root->GetEventTargeter();
   const gfx::Rect bounds = window->bounds();
   const int kNumPoints = 5;
   struct {
     const char* direction;
     gfx::Point location;
     bool is_target_hit;
   } points[kNumPoints] = {
-    { "left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true },
-    { "top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true },
-    { "right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true },
-    { "bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), true },
-    { "outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false },
+      {"left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true},
+      {"top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true},
+      {"right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true},
+      {"bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), true},
+      {"outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false},
   };
   for (int i = 0; i < kNumPoints; ++i) {
     SCOPED_TRACE(points[i].direction);
     const gfx::Point& location = points[i].location;
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, location, location,
                          ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &mouse);
     if (points[i].is_target_hit)
       EXPECT_EQ(window.get(), target);
     else
       EXPECT_NE(window.get(), target);
 
     ui::TouchEvent touch(ui::ET_TOUCH_PRESSED, location, 0,
                          ui::EventTimeForNow());
     target = targeter->FindTargetForEvent(root, &touch);
     if (points[i].is_target_hit)
       EXPECT_EQ(window.get(), target);
     else
       EXPECT_NE(window.get(), target);
   }
 }
 
 }  // namespace ash