clang-format all of //ash

ash/shelf/shelf_view_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/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 54 matching lines @@
 
 namespace ash {
 namespace test {
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfIconObserver tests.
 
 class TestShelfIconObserver : public ShelfIconObserver {
  public:
   explicit TestShelfIconObserver(Shelf* shelf)
-      : shelf_(shelf),
-        change_notified_(false) {
+      : shelf_(shelf), change_notified_(false) {
     if (shelf_)
       shelf_->AddIconObserver(this);
   }
 
   ~TestShelfIconObserver() override {
     if (shelf_)
       shelf_->RemoveIconObserver(this);
   }
 
   // ShelfIconObserver implementation.
@@ skipping 56 matching lines @@
 
   // Resets to the initial state.
   void Reset() { selected_ = false; }
 
   void set_item_selected_action(
       ShelfItemDelegate::PerformedAction item_selected_action) {
     item_selected_action_ = item_selected_action;
   }
 
   // Returns true if the delegate was selected.
-  bool WasSelected() {
-    return selected_;
-  }
+  bool WasSelected() { return selected_; }
 
   // TestShelfItemDelegate:
   ShelfItemDelegate::PerformedAction ItemSelected(
       const ui::Event& event) override {
     selected_ = true;
     return item_selected_action_;
   }
 
  private:
   bool selected_;
@@ skipping 23 matching lines @@
   widget->Show();
   widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow());
   shelf_view_test()->RunMessageLoopUntilAnimationsDone();
   EXPECT_TRUE(observer()->change_notified());
   observer()->Reset();
 }
 
 // Sometimes fails on trybots on win7_aura. http://crbug.com/177135
 #if defined(OS_WIN)
 #define MAYBE_AddRemoveWithMultipleDisplays \
-    DISABLED_AddRemoveWithMultipleDisplays
+  DISABLED_AddRemoveWithMultipleDisplays
 #else
-#define MAYBE_AddRemoveWithMultipleDisplays \
-    AddRemoveWithMultipleDisplays
+#define MAYBE_AddRemoveWithMultipleDisplays AddRemoveWithMultipleDisplays
 #endif
 // Make sure creating/deleting an window on one displays notifies a
 // shelf on external display as well as one on primary.
 TEST_F(ShelfViewIconObserverTest, MAYBE_AddRemoveWithMultipleDisplays) {
   UpdateDisplay("400x400,400x400");
   TestShelfIconObserver second_observer(ShelfForSecondaryDisplay());
 
   TestShelfDelegate* shelf_delegate = TestShelfDelegate::instance();
   ASSERT_TRUE(shelf_delegate);
 
@@ skipping 217 matching lines @@
     int index = model_->ItemIndexByID(id);
     return test_api_->GetButton(index);
   }
 
   ShelfItem GetItemByID(ShelfID id) {
     ShelfItems::const_iterator items = model_->ItemByID(id);
     return *items;
   }
 
   void CheckModelIDs(
-      const std::vector<std::pair<ShelfID, views::View*> >& id_map) {
+      const std::vector<std::pair<ShelfID, views::View*>>& id_map) {
     size_t map_index = 0;
-    for (size_t model_index = 0;
-         model_index < model_->items().size();
+    for (size_t model_index = 0; model_index < model_->items().size();
          ++model_index) {
       ShelfItem item = model_->items()[model_index];
       ShelfID id = item.id;
       EXPECT_EQ(id_map[map_index].first, id);
       EXPECT_EQ(id_map[map_index].second, GetButtonByID(id));
       ++map_index;
     }
     ASSERT_EQ(map_index, id_map.size());
   }
 
@@ skipping 113 matching lines @@
       ShelfView* shelf_view,
       const std::vector<std::pair<int, views::View*>>& expected_id_map) {
     views::View* dragged_button =
         SimulateDrag(ShelfView::MOUSE, from, to, true);
     shelf_view->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE,
                                         false);
     test_api_->RunMessageLoopUntilAnimationsDone();
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(expected_id_map));
   }
 
-  void SetupForDragTest(
-      std::vector<std::pair<ShelfID, views::View*> >* id_map) {
+  void SetupForDragTest(std::vector<std::pair<ShelfID, views::View*>>* id_map) {
     // Initialize |id_map| with the automatically-created shelf buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
       ShelfButton* button = test_api_->GetButton(i);
       id_map->push_back(std::make_pair(model_->items()[i].id, button));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 
     // Add 5 app shelf buttons for testing.
     for (int i = 0; i < 5; ++i) {
       ShelfID id = AddAppShortcut();
@@ skipping 26 matching lines @@
 
     int last_visible_item_id_in_shelf =
         GetItemId(test_api_->GetLastVisibleIndex());
     int second_last_visible_item_id_in_shelf =
         GetItemId(test_api_->GetLastVisibleIndex() - 1);
     int first_visible_item_id_in_overflow =
         GetItemId(test_api_for_overflow.GetFirstVisibleIndex());
     int second_last_visible_item_id_in_overflow =
         GetItemId(test_api_for_overflow.GetLastVisibleIndex() - 1);
 
-    int drag_item_index =
-        test_api_for_overflow.GetLastVisibleIndex();
+    int drag_item_index = test_api_for_overflow.GetLastVisibleIndex();
     ShelfID drag_item_id = GetItemId(drag_item_index);
     ShelfButton* drag_button = test_api_for_overflow.GetButton(drag_item_index);
     gfx::Point center_point_of_drag_item =
         drag_button->GetBoundsInScreen().CenterPoint();
 
     ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
                                        center_point_of_drag_item);
     // Rip an item off to OverflowBubble.
     generator.PressLeftButton();
     gfx::Point rip_off_point(center_point_of_drag_item.x(), 0);
@@ skipping 103 matching lines @@
 
  private:
   void CheckTextDirectionIsCorrect() {
     ASSERT_EQ(is_rtl_, base::i18n::IsRTL());
   }
 
   bool is_rtl_;
   std::string original_locale_;
 };
 
-class ShelfViewTextDirectionTest
-    : public ShelfViewTest,
-      public testing::WithParamInterface<bool> {
+class ShelfViewTextDirectionTest : public ShelfViewTest,
+                                   public testing::WithParamInterface<bool> {
  public:
   ShelfViewTextDirectionTest() : text_direction_change_(GetParam()) {}
   virtual ~ShelfViewTextDirectionTest() {}
 
   void SetUp() override { ShelfViewTest::SetUp(); }
 
   void TearDown() override { ShelfViewTest::TearDown(); }
 
  private:
   ScopedTextDirectionChange text_direction_change_;
@@ skipping 41 matching lines @@
   // identical whereas the first one does not match either of them.
   EXPECT_EQ(first_bounds.size().ToString(), last_bounds.size().ToString());
   EXPECT_NE(first_bounds.ToString(), last_bounds.ToString());
   EXPECT_EQ(overflow_bounds.ToString(), last_bounds.ToString());
 }
 
 // Checks that shelf view contents are considered in the correct drag group.
 TEST_F(ShelfViewTest, EnforceDragType) {
   EXPECT_TRUE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_PLATFORM_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_SHORTCUT));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP,
-                                       TYPE_BROWSER_SHORTCUT));
+  EXPECT_FALSE(
+      test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_BROWSER_SHORTCUT));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_SHORTCUT));
-  EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_SHORTCUT,
-                                      TYPE_BROWSER_SHORTCUT));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT,
-                                       TYPE_WINDOWED_APP));
+  EXPECT_TRUE(
+      test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_BROWSER_SHORTCUT));
+  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_PANEL));
 
-  EXPECT_TRUE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT,
-                                      TYPE_BROWSER_SHORTCUT));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT,
-                                       TYPE_WINDOWED_APP));
+  EXPECT_TRUE(
+      test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_BROWSER_SHORTCUT));
+  EXPECT_FALSE(
+      test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_PANEL, TYPE_APP_PANEL));
 }
 
 // Adds platform app button until overflow and verifies that the last added
 // platform app button is hidden.
 TEST_F(ShelfViewTest, AddBrowserUntilOverflow) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow.
   int items_added = 0;
   ShelfID last_added = AddPlatformApp();
   while (!test_api_->IsOverflowButtonVisible()) {
     // Added button is visible after animation while in this loop.
     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 
     last_added = AddPlatformApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // The last added button should be invisible.
   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 }
 
 // Adds one platform app button then adds app shortcut until overflow. Verifies
 // that the browser button gets hidden on overflow and last added app shortcut
 // is still visible.
 TEST_F(ShelfViewTest, AddAppShortcutWithBrowserButtonUntilOverflow) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   ShelfID browser_button_id = AddPlatformApp();
 
   // Add app shortcut until overflow.
   int items_added = 0;
   ShelfID last_added = AddAppShortcut();
   while (!test_api_->IsOverflowButtonVisible()) {
     // Added button is visible after animation while in this loop.
     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 
     last_added = AddAppShortcut();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // And the platform app button is invisible.
   EXPECT_FALSE(GetButtonByID(browser_button_id)->visible());
 }
 
 TEST_F(ShelfViewTest, AddPanelHidesPlatformAppButton) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow, remember last visible platform app
   // button.
   int items_added = 0;
   ShelfID first_added = AddPlatformApp();
   EXPECT_TRUE(GetButtonByID(first_added)->visible());
   while (true) {
     ShelfID added = AddPlatformApp();
     if (test_api_->IsOverflowButtonVisible()) {
       EXPECT_FALSE(GetButtonByID(added)->visible());
       RemoveByID(added);
       break;
     }
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   ShelfID panel = AddPanel();
   EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
 
   RemoveByID(panel);
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // When there are more panels then platform app buttons we should hide panels
 // rather than platform apps.
 TEST_F(ShelfViewTest, PlatformAppHidesExcessPanels) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID platform_app = AddPlatformApp();
   ShelfID first_panel = AddPanel();
 
   EXPECT_TRUE(GetButtonByID(platform_app)->visible());
   EXPECT_TRUE(GetButtonByID(first_panel)->visible());
 
   // Add panels until there is an overflow.
   ShelfID last_panel = first_panel;
@@ skipping 106 matching lines @@
     EXPECT_EQ(kArrows[i],
               bubble_view_api.GetBubbleFrameView()->bubble_border()->arrow());
   }
 }
 
 // Adds button until overflow then removes first added one. Verifies that
 // the last added one changes from invisible to visible and overflow
 // chevron is gone.
 TEST_F(ShelfViewTest, RemoveButtonRevealsOverflowed) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app buttons until overflow.
   int items_added = 0;
   ShelfID first_added = AddPlatformApp();
   ShelfID last_added = first_added;
   while (!test_api_->IsOverflowButtonVisible()) {
     last_added = AddPlatformApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // Expect add more than 1 button. First added is visible and last is not.
   EXPECT_NE(first_added, last_added);
   EXPECT_TRUE(GetButtonByID(first_added)->visible());
   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 
   // Remove first added.
   RemoveByID(first_added);
 
   // Last added button becomes visible and overflow chevron is gone.
   EXPECT_TRUE(GetButtonByID(last_added)->visible());
   EXPECT_EQ(1.0f, GetButtonByID(last_added)->layer()->opacity());
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // Verifies that remove last overflowed button should hide overflow chevron.
 TEST_F(ShelfViewTest, RemoveLastOverflowed) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow.
   int items_added = 0;
   ShelfID last_added = AddPlatformApp();
   while (!test_api_->IsOverflowButtonVisible()) {
     last_added = AddPlatformApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   RemoveByID(last_added);
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // Adds platform app button without waiting for animation to finish and verifies
 // that all added buttons are visible.
 TEST_F(ShelfViewTest, AddButtonQuickly) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add a few platform buttons quickly without wait for animation.
   int added_count = 0;
   while (!test_api_->IsOverflowButtonVisible()) {
     AddPlatformAppNoWait();
     ++added_count;
     ASSERT_LT(added_count, 10000);
   }
 
   // ShelfView should be big enough to hold at least 3 new buttons.
   ASSERT_GE(added_count, 3);
 
   // Wait for the last animation to finish.
   test_api_->RunMessageLoopUntilAnimationsDone();
 
   // Verifies non-overflow buttons are visible.
   for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
     ShelfButton* button = test_api_->GetButton(i);
     if (button) {
       EXPECT_TRUE(button->visible()) << "button index=" << i;
       EXPECT_EQ(1.0f, button->layer()->opacity()) << "button index=" << i;
     }
   }
 }
 
 // Check that model changes are handled correctly while a shelf icon is being
 // dragged.
 TEST_F(ShelfViewTest, ModelChangesWhileDragging) {
-  std::vector<std::pair<ShelfID, views::View*> > id_map;
+  std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 1.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
   views::View* dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
-  std::rotate(id_map.begin() + 1,
-              id_map.begin() + 2,
-              id_map.begin() + 4);
+  std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 
   // Dragging changes model order.
   dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
-  std::rotate(id_map.begin() + 1,
-              id_map.begin() + 2,
-              id_map.begin() + 4);
+  std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Cancelling the drag operation restores previous order.
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, true);
-  std::rotate(id_map.begin() + 1,
-              id_map.begin() + 3,
-              id_map.begin() + 4);
+  std::rotate(id_map.begin() + 1, id_map.begin() + 3, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Deleting an item keeps the remaining intact.
   dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 
   // Adding a shelf item cancels the drag and respects the order.
   dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   ShelfID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 6,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 
   // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
   dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 }
 
 // Check that 2nd drag from the other pointer would be ignored.
 TEST_F(ShelfViewTest, SimultaneousDrag) {
-  std::vector<std::pair<ShelfID, views::View*> > id_map;
+  std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   // Start a mouse drag.
   views::View* dragged_button_mouse =
       SimulateDrag(ShelfView::MOUSE, 1, 3, false);
-  std::rotate(id_map.begin() + 1,
-              id_map.begin() + 2,
-              id_map.begin() + 4);
+  std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   // Attempt a touch drag before the mouse drag finishes.
   views::View* dragged_button_touch =
       SimulateDrag(ShelfView::TOUCH, 4, 2, false);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Finish the mouse drag.
   shelf_view_->PointerReleasedOnButton(dragged_button_mouse, ShelfView::MOUSE,
                                        false);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Now start a touch drag.
   dragged_button_touch = SimulateDrag(ShelfView::TOUCH, 4, 2, false);
-  std::rotate(id_map.begin() + 3,
-              id_map.begin() + 4,
-              id_map.begin() + 5);
+  std::rotate(id_map.begin() + 3, id_map.begin() + 4, id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // And attempt a mouse drag before the touch drag finishes.
   dragged_button_mouse = SimulateDrag(ShelfView::MOUSE, 1, 2, false);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   shelf_view_->PointerReleasedOnButton(dragged_button_touch, ShelfView::TOUCH,
                                        false);
@@ skipping 18 matching lines @@
 
   std::rotate(id_map.begin() + 3, id_map.begin() + 4, id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(4, 1, shelf_view_, id_map));
   std::rotate(id_map.begin() + 3, id_map.begin() + 5, id_map.begin() + 6);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(5, 1, shelf_view_, id_map));
 }
 
 // Check that clicking first on one item and then dragging another works as
 // expected.
 TEST_F(ShelfViewTest, ClickOneDragAnother) {
-  std::vector<std::pair<ShelfID, views::View*> > id_map;
+  std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   // A click on item 1 is simulated.
   SimulateClick(1);
 
   // Dragging browser index at 0 should change the model order correctly.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
   views::View* dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
@@ skipping 15 matching lines @@
 
   // A double-click does not select the item.
   selection_tracker->Reset();
   SimulateDoubleClick(browser_index_);
   EXPECT_FALSE(selection_tracker->WasSelected());
 }
 
 // Check that clicking an item and jittering the mouse a bit still selects the
 // item.
 TEST_F(ShelfViewTest, ClickAndMoveSlightly) {
-  std::vector<std::pair<ShelfID, views::View*> > id_map;
+  std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   ShelfID shelf_id = (id_map.begin() + 1)->first;
   views::View* button = (id_map.begin() + 1)->second;
 
   // Replace the ShelfItemDelegate for |shelf_id| with one which tracks whether
   // the shelf item gets selected.
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
   item_manager_->SetShelfItemDelegate(
       shelf_id, std::unique_ptr<ShelfItemDelegate>(selection_tracker));
@@ skipping 25 matching lines @@
       press_location_in_screen + gfx::Vector2d(-1, 0), ui::EventTimeForNow(),
       ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
 
   EXPECT_TRUE(selection_tracker->WasSelected());
 }
 
 // Confirm that item status changes are reflected in the buttons.
 TEST_F(ShelfViewTest, ShelfItemStatus) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID last_added = AddPlatformApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 // Confirm that item status changes are reflected in the buttons
 // for platform apps.
 TEST_F(ShelfViewTest, ShelfItemStatusPlatformApp) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID last_added = AddPlatformApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
@@ skipping 208 matching lines @@
   // Wait until the delayed close kicked in.
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(tooltip_manager->IsVisible());
 }
 
 // Resizing shelf view while an add animation without fade-in is running,
 // which happens when overflow happens. App list button should end up in its
 // new ideal bounds.
 TEST_F(ShelfViewTest, ResizeDuringOverflowAddAnimation) {
   // All buttons should be visible.
-  ASSERT_EQ(test_api_->GetButtonCount(),
-            test_api_->GetLastVisibleIndex() + 1);
+  ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add buttons until overflow. Let the non-overflow add animations finish but
   // leave the last running.
   int items_added = 0;
   AddPlatformAppNoWait();
   while (!test_api_->IsOverflowButtonVisible()) {
     test_api_->RunMessageLoopUntilAnimationsDone();
     AddPlatformAppNoWait();
     ++items_added;
     ASSERT_LT(items_added, 10000);
@@ skipping 29 matching lines @@
   test_api_->ShowOverflowBubble();
   ASSERT_TRUE(test_api_->overflow_bubble() &&
               test_api_->overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_for_overflow_view(
       test_api_->overflow_bubble()->shelf_view());
 
   int ripped_index = test_for_overflow_view.GetLastVisibleIndex();
   gfx::Size bubble_size = test_for_overflow_view.GetPreferredSize();
   int item_width = test_for_overflow_view.GetButtonSize() +
-      test_for_overflow_view.GetButtonSpacing();
+                   test_for_overflow_view.GetButtonSpacing();
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      gfx::Point());
   ShelfButton* button = test_for_overflow_view.GetButton(ripped_index);
   // Rip off the last visible item.
   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
   gfx::Point rip_off_point(start_point.x(), 0);
   generator.MoveMouseTo(start_point.x(), start_point.y());
   base::RunLoop().RunUntilIdle();
   generator.PressLeftButton();
@@ skipping 105 matching lines @@
 
   ShelfButton* button = test_api_for_overflow_view.GetButton(
       test_api_for_overflow_view.GetLastVisibleIndex());
 
   // Checks that a point in shelf is contained in drag insert bounds.
   gfx::Point point_in_shelf_view = button->GetBoundsInScreen().CenterPoint();
   gfx::Rect drag_reinsert_bounds =
       test_api_for_overflow_view.GetBoundsForDragInsertInScreen();
   EXPECT_TRUE(drag_reinsert_bounds.Contains(point_in_shelf_view));
   // Checks that a point out of shelf is not contained in drag insert bounds.
-  EXPECT_FALSE(drag_reinsert_bounds.Contains(
-      gfx::Point(point_in_shelf_view.x(), 0)));
+  EXPECT_FALSE(
+      drag_reinsert_bounds.Contains(gfx::Point(point_in_shelf_view.x(), 0)));
 
   // Test #2: Test drag insertion bounds of secondary shelf.
   // Show overflow bubble.
   test_api_for_secondary.ShowOverflowBubble();
   ASSERT_TRUE(test_api_for_secondary.overflow_bubble() &&
               test_api_for_secondary.overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_api_for_overflow_view_of_secondary(
       test_api_for_secondary.overflow_bubble()->shelf_view());
 
@@ skipping 83 matching lines @@
   EXPECT_FALSE(GetButtonByID(platform_app_id)->visible());
 }
 
 // Tests that the AppListButton renders as active in response to touches.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedback) {
   AppListButton* app_list_button =
       static_cast<AppListButton*>(shelf_view_->GetAppListButtonView());
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.set_current_location(app_list_button->
-      GetBoundsInScreen().CenterPoint());
+  generator.set_current_location(
+      app_list_button->GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
   generator.ReleaseTouch();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
   EXPECT_TRUE(Shell::GetInstance()->GetAppListTargetVisibility());
 }
 
 // Tests that a touch that slides out of the bounds of the AppListButton leads
 // to the end of rendering an active state.
 TEST_F(ShelfViewTest, AppListButtonTouchFeedbackCancellation) {
   AppListButton* app_list_button =
       static_cast<AppListButton*>(shelf_view_->GetAppListButtonView());
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
-  generator.set_current_location(app_list_button->
-      GetBoundsInScreen().CenterPoint());
+  generator.set_current_location(
+      app_list_button->GetBoundsInScreen().CenterPoint());
   generator.PressTouch();
   EXPECT_TRUE(app_list_button->draw_background_as_active());
 
-  gfx::Point moved_point(app_list_button->GetBoundsInScreen().right() + 1,
-                         app_list_button->
-                             GetBoundsInScreen().CenterPoint().y());
+  gfx::Point moved_point(
+      app_list_button->GetBoundsInScreen().right() + 1,
+      app_list_button->GetBoundsInScreen().CenterPoint().y());
   generator.MoveTouch(moved_point);
   EXPECT_FALSE(app_list_button->draw_background_as_active());
 
   generator.set_current_location(moved_point);
   generator.ReleaseTouch();
   EXPECT_FALSE(app_list_button->draw_background_as_active());
   EXPECT_FALSE(Shell::GetInstance()->GetAppListTargetVisibility());
 }
 
 // Verifies that Launcher_ButtonPressed_* UMA user actions are recorded when an
@@ skipping 67 matching lines @@
     gfx::Rect shelf_bounds = shelf_view_->GetBoundsInScreen();
     EXPECT_TRUE(shelf_bounds.Contains(visible_bounds));
     for (int i = 0; i < test_api_->GetButtonCount(); ++i)
       if (ShelfButton* button = test_api_->GetButton(i))
         EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen()));
     CheckAppListButtonIsInBounds();
   }
 
   void CheckAppListButtonIsInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
-    gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()->
-       GetBoundsInScreen();
+    gfx::Rect app_list_button_bounds =
+        shelf_view_->GetAppListButtonView()->GetBoundsInScreen();
     EXPECT_TRUE(visible_bounds.Contains(app_list_button_bounds));
   }
 
  private:
   ScopedTextDirectionChange text_direction_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewVisibleBoundsTest);
 };
 
 TEST_P(ShelfViewVisibleBoundsTest, ItemsAreInBounds) {
   // Adding elements leaving some empty space.
   for (int i = 0; i < 3; i++) {
     AddAppShortcut();
   }
   test_api_->RunMessageLoopUntilAnimationsDone();
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
   CheckAllItemsAreInBounds();
   // Same for overflow case.
   while (!test_api_->IsOverflowButtonVisible()) {
     AddAppShortcut();
   }
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
-INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
-    testing::Bool());
+INSTANTIATE_TEST_CASE_P(VisibleBounds,
+                        ShelfViewVisibleBoundsTest,
+                        testing::Bool());
 
 namespace {
 
 // An InkDrop implementation that wraps another InkDrop instance to keep track
 // of state changes requested on it. Note that this will only track transitions
 // routed through AnimateToState() and not the ones performed directly on the
 // ripple inside the contained |ink_drop|.
 class InkDropSpy : public views::InkDrop {
  public:
   explicit InkDropSpy(std::unique_ptr<views::InkDrop> ink_drop)
@@ skipping 260 matching lines @@
                                ui::EF_LEFT_MOUSE_BUTTON, 0);
   button->OnMouseReleased(release_event);
   EXPECT_EQ(views::InkDropState::HIDDEN, ink_drop_->GetTargetInkDropState());
   EXPECT_THAT(ink_drop_->GetAndResetRequestedStates(),
               ElementsAre(views::InkDropState::ACTIVATED,
                           views::InkDropState::DEACTIVATED));
 }
 
 }  // namespace test
 }  // namespace ash