clang-format all of //ash

ash/shelf/shelf_view.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 "ash/aura/wm_window_aura.h"
@@ skipping 67 matching lines @@
 
 // The proportion of the shelf space reserved for non-panel icons. Panels
 // may flow into this space but will be put into the overflow bubble if there
 // is contention for the space.
 const float kReservedNonPanelIconProportion = 0.67f;
 
 // This is the command id of the menu item which contains the name of the menu.
 const int kCommandIdOfMenuName = 0;
 
 // The background color of the active item in the list.
-const SkColor kActiveListItemBackgroundColor = SkColorSetRGB(203 , 219, 241);
+const SkColor kActiveListItemBackgroundColor = SkColorSetRGB(203, 219, 241);
 
 // The background color of the active & hovered item in the list.
 const SkColor kFocusedActiveListItemBackgroundColor =
     SkColorSetRGB(193, 211, 236);
 
 // The text color of the caption item in a list.
 const SkColor kCaptionItemForegroundColor = SK_ColorBLACK;
 
 // The maximum allowable length of a menu line of an application menu in pixels.
 const int kMaximumAppMenuItemLength = 350;
@@ skipping 55 matching lines @@
   int GetMaxWidthForMenu(views::MenuItemView* menu) override;
   bool ShouldReserveSpaceForSubmenuIndicator() const override;
 
  private:
   ShelfMenuModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfMenuModelAdapter);
 };
 
 ShelfMenuModelAdapter::ShelfMenuModelAdapter(ShelfMenuModel* menu_model)
-    : MenuModelAdapter(menu_model),
-      menu_model_(menu_model) {
-}
+    : MenuModelAdapter(menu_model), menu_model_(menu_model) {}
 
 const gfx::FontList* ShelfMenuModelAdapter::GetLabelFontList(
     int command_id) const {
   if (command_id != kCommandIdOfMenuName)
     return MenuModelAdapter::GetLabelFontList(command_id);
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   return &rb->GetFontList(ui::ResourceBundle::BoldFont);
 }
 
@@ skipping 10 matching lines @@
   *override_color = kCaptionItemForegroundColor;
   return true;
 }
 
 bool ShelfMenuModelAdapter::GetBackgroundColor(int command_id,
                                                bool is_hovered,
                                                SkColor* override_color) const {
   if (!menu_model_->IsCommandActive(command_id))
     return false;
 
-  *override_color = is_hovered ? kFocusedActiveListItemBackgroundColor :
-                                 kActiveListItemBackgroundColor;
+  *override_color = is_hovered ? kFocusedActiveListItemBackgroundColor
+                               : kActiveListItemBackgroundColor;
   return true;
 }
 
 void ShelfMenuModelAdapter::GetHorizontalIconMargins(int command_id,
                                                      int icon_size,
                                                      int* left_margin,
                                                      int* right_margin) const {
   *left_margin = kHorizontalIconSpacing;
-  *right_margin = (command_id != kCommandIdOfMenuName) ?
-      kHorizontalIconSpacing : -(icon_size + kHorizontalNoIconInsetSpacing);
+  *right_margin = (command_id != kCommandIdOfMenuName)
+                      ? kHorizontalIconSpacing
+                      : -(icon_size + kHorizontalNoIconInsetSpacing);
 }
 
 int ShelfMenuModelAdapter::GetMaxWidthForMenu(views::MenuItemView* menu) {
   return kMaximumAppMenuItemLength;
 }
 
 bool ShelfMenuModelAdapter::ShouldReserveSpaceForSubmenuIndicator() const {
   return false;
 }
 
@@ skipping 86 matching lines @@
   }
 }
 
 }  // namespace
 
 // AnimationDelegate used when deleting an item. This steadily decreased the
 // opacity of the layer as the animation progress.
 class ShelfView::FadeOutAnimationDelegate : public gfx::AnimationDelegate {
  public:
   FadeOutAnimationDelegate(ShelfView* host, views::View* view)
-      : shelf_view_(host),
-        view_(view) {}
+      : shelf_view_(host), view_(view) {}
   ~FadeOutAnimationDelegate() override {}
 
   // AnimationDelegate overrides:
   void AnimationProgressed(const Animation* animation) override {
     view_->layer()->SetOpacity(1 - animation->GetCurrentValue());
     view_->layer()->ScheduleDraw();
   }
   void AnimationEnded(const Animation* animation) override {
     shelf_view_->OnFadeOutAnimationEnded();
   }
   void AnimationCanceled(const Animation* animation) override {}
 
  private:
   ShelfView* shelf_view_;
   std::unique_ptr<views::View> view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeOutAnimationDelegate);
 };
 
 // AnimationDelegate used to trigger fading an element in. When an item is
 // inserted this delegate is attached to the animation that expands the size of
 // the item.  When done it kicks off another animation to fade the item in.
 class ShelfView::StartFadeAnimationDelegate : public gfx::AnimationDelegate {
  public:
-  StartFadeAnimationDelegate(ShelfView* host,
-                             views::View* view)
-      : shelf_view_(host),
-        view_(view) {}
+  StartFadeAnimationDelegate(ShelfView* host, views::View* view)
+      : shelf_view_(host), view_(view) {}
   ~StartFadeAnimationDelegate() override {}
 
   // AnimationDelegate overrides:
   void AnimationEnded(const Animation* animation) override {
     shelf_view_->FadeIn(view_);
   }
   void AnimationCanceled(const Animation* animation) override {
     view_->layer()->SetOpacity(1.0f);
   }
 
@@ skipping 114 matching lines @@
   if (index > last_visible_index_ && index < model_->FirstPanelIndex())
     index = last_visible_index_ + 1;
   const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
   DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
   views::View* view = view_model_->view_at(index);
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   ShelfButton* button = static_cast<ShelfButton*>(view);
   gfx::Rect icon_bounds = button->GetIconBounds();
   return gfx::Rect(GetMirroredXWithWidthInView(
                        ideal_bounds.x() + icon_bounds.x(), icon_bounds.width()),
-                   ideal_bounds.y() + icon_bounds.y(),
-                   icon_bounds.width(),
+                   ideal_bounds.y() + icon_bounds.y(), icon_bounds.width(),
                    icon_bounds.height());
 }
 
 void ShelfView::UpdatePanelIconPosition(ShelfID id,
                                         const gfx::Point& midpoint) {
   int current_index = model_->ItemIndexByID(id);
   int first_panel_index = model_->FirstPanelIndex();
   if (current_index < first_panel_index)
     return;
 
-  gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()),
-                              midpoint.y());
+  gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()), midpoint.y());
   int target_index = current_index;
   while (target_index > first_panel_index &&
          shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
                                   view_model_->ideal_bounds(target_index).y()) >
              shelf_->PrimaryAxisValue(midpoint_in_view.x(),
                                       midpoint_in_view.y())) {
     --target_index;
   }
   while (target_index < view_model_->view_size() - 1 &&
          shelf_->PrimaryAxisValue(
@@ skipping 85 matching lines @@
   drag_image_.reset(new DragImageView(
       drag_replaced_view_->GetWidget()->GetNativeWindow()->GetRootWindow(),
       ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE));
   drag_image_->SetImage(icon);
   gfx::Size size = drag_image_->GetPreferredSize();
   size.set_width(size.width() * scale_factor);
   size.set_height(size.height() * scale_factor);
   drag_image_offset_ = gfx::Vector2d(size.width() / 2, size.height() / 2) +
                        cursor_offset_from_center;
   gfx::Rect drag_image_bounds(
-      location_in_screen_coordinates - drag_image_offset_,
-      size);
+      location_in_screen_coordinates - drag_image_offset_, size);
   drag_image_->SetBoundsInScreen(drag_image_bounds);
   drag_image_->SetWidgetVisible(true);
 }
 
 void ShelfView::UpdateDragIconProxy(
     const gfx::Point& location_in_screen_coordinates) {
   // TODO(jennyz): Investigate why drag_image_ becomes null at this point per
   // crbug.com/34722, while the app list item is still being dragged around.
   if (drag_image_) {
-    drag_image_->SetScreenPosition(
-        location_in_screen_coordinates - drag_image_offset_);
+    drag_image_->SetScreenPosition(location_in_screen_coordinates -
+                                   drag_image_offset_);
   }
 }
 
 void ShelfView::DestroyDragIconProxy() {
   drag_image_.reset();
   drag_image_offset_ = gfx::Vector2d(0, 0);
 }
 
 bool ShelfView::StartDrag(const std::string& app_id,
                           const gfx::Point& location_in_screen_coordinates) {
   // Bail if an operation is already going on - or the cursor is not inside.
   // This could happen if mouse / touch operations overlap.
   if (drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   // If the AppsGridView (which was dispatching this event) was opened by our
   // button, ShelfView dragging operations are locked and we have to unlock.
   CancelDrag(-1);
   drag_and_drop_item_pinned_ = false;
   drag_and_drop_app_id_ = app_id;
   drag_and_drop_shelf_id_ =
       delegate_->GetShelfIDForAppID(drag_and_drop_app_id_);
   // Check if the application is known and pinned - if not, we have to pin it so
   // that we can re-arrange the shelf order accordingly. Note that items have
   // to be pinned to give them the same (order) possibilities as a shortcut.
   // When an item is dragged from overflow to shelf, IsShowingOverflowBubble()
   // returns true. At this time, we don't need to pin the item.
   if (!IsShowingOverflowBubble() &&
-      (!drag_and_drop_shelf_id_ ||
-       !delegate_->IsAppPinned(app_id))) {
+      (!drag_and_drop_shelf_id_ || !delegate_->IsAppPinned(app_id))) {
     delegate_->PinAppWithID(app_id);
     drag_and_drop_shelf_id_ =
         delegate_->GetShelfIDForAppID(drag_and_drop_app_id_);
     if (!drag_and_drop_shelf_id_)
       return false;
     drag_and_drop_item_pinned_ = true;
   }
-  views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_shelf_id_));
+  views::View* drag_and_drop_view =
+      view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   DCHECK(drag_and_drop_view);
 
   // Since there is already an icon presented by the caller, we hide this item
   // for now. That has to be done by reducing the size since the visibility will
   // change once a regrouping animation is performed.
   pre_drag_and_drop_size_ = drag_and_drop_view->size();
   drag_and_drop_view->SetSize(gfx::Size());
 
   // First we have to center the mouse cursor over the item.
   gfx::Point pt = drag_and_drop_view->GetBoundsInScreen().CenterPoint();
@@ skipping 11 matching lines @@
   Drag(location_in_screen_coordinates);
   return true;
 }
 
 bool ShelfView::Drag(const gfx::Point& location_in_screen_coordinates) {
   if (!drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   gfx::Point pt = location_in_screen_coordinates;
-  views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_shelf_id_));
+  views::View* drag_and_drop_view =
+      view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root = location_in_screen_coordinates;
   ::wm::ConvertPointFromScreen(
       WmWindowAura::GetAuraWindow(
           ash::wm::GetRootWindowAt(location_in_screen_coordinates)),
       &point_in_root);
   ui::MouseEvent event(ui::ET_MOUSE_DRAGGED, pt, point_in_root,
                        ui::EventTimeForNow(), 0, 0);
   PointerDraggedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
   return true;
 }
 
 void ShelfView::EndDrag(bool cancel) {
   if (!drag_and_drop_shelf_id_)
     return;
 
-  views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_shelf_id_));
+  views::View* drag_and_drop_view =
+      view_model_->view_at(model_->ItemIndexByID(drag_and_drop_shelf_id_));
   PointerReleasedOnButton(drag_and_drop_view, DRAG_AND_DROP, cancel);
 
   // Either destroy the temporarily created item - or - make the item visible.
   if (drag_and_drop_item_pinned_ && cancel) {
     delegate_->UnpinAppWithID(drag_and_drop_app_id_);
   } else if (drag_and_drop_view) {
     if (cancel) {
       // When a hosted drag gets canceled, the item can remain in the same slot
       // and it might have moved within the bounds. In that case the item need
       // to animate back to its correct location.
@@ skipping 102 matching lines @@
   CalculateIdealBounds(&ideal_bounds);
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 void ShelfView::UpdateAllButtonsVisibilityInOverflowMode() {
   // The overflow button is not shown in overflow mode.
   overflow_button_->SetVisible(false);
   DCHECK_LT(last_visible_index_, view_model_->view_size());
   for (int i = 0; i < view_model_->view_size(); ++i) {
-    bool visible = i >= first_visible_index_ &&
-        i <= last_visible_index_;
+    bool visible = i >= first_visible_index_ && i <= last_visible_index_;
     // To track the dragging of |drag_view_| continuously, its visibility
     // should be always true regardless of its position.
     if (dragged_off_from_overflow_to_shelf_ &&
         view_model_->view_at(i) == drag_view_)
       view_model_->view_at(i)->SetVisible(true);
     else
       view_model_->view_at(i)->SetVisible(visible);
   }
 }
 
@@ skipping 26 matching lines @@
 
   if (is_overflow_mode()) {
     const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
   // Right aligned icons.
   int end_position = available_size - button_spacing;
   x = shelf_->PrimaryAxisValue(end_position, 0);
   y = shelf_->PrimaryAxisValue(0, end_position);
-  for (int i = view_model_->view_size() - 1;
-       i >= first_panel_index; --i) {
+  for (int i = view_model_->view_size() - 1; i >= first_panel_index; --i) {
     x = shelf_->PrimaryAxisValue(x - w - button_spacing, x);
     y = shelf_->PrimaryAxisValue(y, y - h - button_spacing);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
     end_position = shelf_->PrimaryAxisValue(x, y);
   }
 
   // Icons on the left / top are guaranteed up to kLeftIconProportion of
   // the available space.
   int last_icon_position =
       shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_button_index).right(),
           view_model_->ideal_bounds(last_button_index).bottom()) +
       button_size;
   int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
   if (last_icon_position < reserved_icon_space)
     end_position = last_icon_position;
   else
     end_position = std::max(end_position, reserved_icon_space);
 
   bounds->overflow_bounds.set_size(
       gfx::Size(shelf_->PrimaryAxisValue(w, width()),
                 shelf_->PrimaryAxisValue(height(), h)));
 
-  last_visible_index_ = DetermineLastVisibleIndex(
-      end_position - button_size);
+  last_visible_index_ = DetermineLastVisibleIndex(end_position - button_size);
   last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
   bool show_overflow = last_visible_index_ < last_button_index ||
-      last_hidden_index_ >= first_panel_index;
+                       last_hidden_index_ >= first_panel_index;
 
   // Create Space for the overflow button
   if (show_overflow) {
     // The following code makes sure that platform apps icons (aligned to left /
     // top) are favored over panel apps icons (aligned to right / bottom).
     if (last_visible_index_ > 0 && last_visible_index_ < last_button_index) {
       // This condition means that we will take one platform app and replace it
       // with the overflow button and put the app in the overflow bubble.
       // This happens when the space needed for platform apps exceeds the
       // reserved area for non-panel icons,
@@ skipping 137 matching lines @@
       view, std::unique_ptr<gfx::AnimationDelegate>(
                 new FadeInAnimationDelegate(view)));
 }
 
 void ShelfView::PrepareForDrag(Pointer pointer, const ui::LocatedEvent& event) {
   DCHECK(!dragging());
   DCHECK(drag_view_);
   drag_pointer_ = pointer;
   start_drag_index_ = view_model_->GetIndexOfView(drag_view_);
 
-  if (start_drag_index_== -1) {
+  if (start_drag_index_ == -1) {
     CancelDrag(-1);
     return;
   }
 
   // If the item is no longer draggable, bail out.
   ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[start_drag_index_].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
@@ skipping 38 matching lines @@
   int first_drag_index = indices.first;
   int last_drag_index = indices.second;
   // If the last index isn't valid, we're overflowing. Constrain to the app list
   // (which is the last visible item).
   if (first_drag_index < model_->FirstPanelIndex() &&
       last_drag_index > last_visible_index_)
     last_drag_index = last_visible_index_;
   int x = 0, y = 0;
   if (shelf_->IsHorizontalAlignment()) {
     x = std::max(view_model_->ideal_bounds(indices.first).x(),
-                     drag_point.x() - drag_origin_.x());
+                 drag_point.x() - drag_origin_.x());
     x = std::min(view_model_->ideal_bounds(last_drag_index).right() -
-                 view_model_->ideal_bounds(current_index).width(),
+                     view_model_->ideal_bounds(current_index).width(),
                  x);
     if (drag_view_->x() == x)
       return;
     drag_view_->SetX(x);
   } else {
     y = std::max(view_model_->ideal_bounds(indices.first).y(),
-                     drag_point.y() - drag_origin_.y());
+                 drag_point.y() - drag_origin_.y());
     y = std::min(view_model_->ideal_bounds(last_drag_index).bottom() -
-                 view_model_->ideal_bounds(current_index).height(),
+                     view_model_->ideal_bounds(current_index).height(),
                  y);
     if (drag_view_->y() == y)
       return;
     drag_view_->SetY(y);
   }
 
   int target_index = views::ViewModelUtils::DetermineMoveIndex(
       *view_model_, drag_view_,
       shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
                                       : views::ViewModelUtils::VERTICAL,
       x, y);
   target_index =
       std::min(indices.second, std::max(target_index, indices.first));
 
   int first_draggable_item = 0;
   while (first_draggable_item < static_cast<int>(model_->items().size()) &&
-         !item_manager_->GetShelfItemDelegate(
-                           model_->items()[first_draggable_item].id)
+         !item_manager_
+              ->GetShelfItemDelegate(model_->items()[first_draggable_item].id)
               ->IsDraggable()) {
     first_draggable_item++;
   }
 
   target_index = std::max(target_index, first_draggable_item);
 
   if (target_index == current_index)
     return;
 
   // Change the model, the ShelfItemMoved() callback will handle the
@@ skipping 62 matching lines @@
     }
     // Move our proxy view item.
     UpdateDragIconProxy(screen_location);
     return true;
   }
   // Check if we are too far away from the shelf to enter the ripped off state.
   // Determine the distance to the shelf.
   int delta = CalculateShelfDistance(screen_location);
   if (delta > kRipOffDistance) {
     // Create a proxy view item which can be moved anywhere.
-    CreateDragIconProxy(event.root_location(),
-                        drag_view_->GetImage(),
-                        drag_view_,
-                        gfx::Vector2d(0, 0),
+    CreateDragIconProxy(event.root_location(), drag_view_->GetImage(),
+                        drag_view_, gfx::Vector2d(0, 0),
                         kDragAndDropProxyScale);
     drag_view_->layer()->SetOpacity(0.0f);
     dragged_off_shelf_ = true;
     if (RemovableByRipOff(current_index) == REMOVABLE) {
       // Move the item to the front of the first panel item and hide it.
       // ShelfItemMoved() callback will handle the |view_model_| update and
       // call AnimateToIdealBounds().
       if (current_index != model_->FirstPanelIndex() - 1) {
         model_->Move(current_index, model_->FirstPanelIndex() - 1);
         StartFadeInLastVisibleItem();
@@ skipping 52 matching lines @@
     if (dragged_off_from_overflow_to_shelf_) {
       dragged_off_from_overflow_to_shelf_ = false;
       // Main shelf handles revert of dragged item.
       main_shelf_->EndDrag(true);
       drag_view_->layer()->SetOpacity(1.0f);
     } else if (!cancelling_drag_model_changed_) {
       // Only do something if the change did not come through a model change.
       gfx::Rect drag_bounds = drag_image_->GetBoundsInScreen();
       gfx::Point relative_to = GetBoundsInScreen().origin();
       gfx::Rect target(
-          gfx::PointAtOffsetFromOrigin(drag_bounds.origin()- relative_to),
+          gfx::PointAtOffsetFromOrigin(drag_bounds.origin() - relative_to),
           drag_bounds.size());
       drag_view_->SetBoundsRect(target);
       // Hide the status from the active item since we snap it back now. Upon
       // animation end the flag gets cleared if |snap_back_from_rip_off_view_|
       // is set.
       snap_back_from_rip_off_view_ = drag_view_;
       drag_view_->AddState(ShelfButton::STATE_HIDDEN);
       // When a canceling drag model is happening, the view model is diverged
       // from the menu model and movements / animations should not be done.
       model_->Move(current_index, start_drag_index_);
       AnimateToIdealBounds();
     }
     drag_view_->layer()->SetOpacity(1.0f);
   }
   DestroyDragIconProxy();
 }
 
 ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) const {
   DCHECK(index >= 0 && index < model_->item_count());
   ShelfItemType type = model_->items()[index].type;
   if (type == TYPE_APP_LIST || type == TYPE_DIALOG)
     return NOT_REMOVABLE;
 
   std::string app_id = delegate_->GetAppIDForShelfID(model_->items()[index].id);
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(model_->items()[index].id);
   if (!item_delegate->CanPin())
     return NOT_REMOVABLE;
   // Note: Only pinned app shortcuts can be removed!
-  return (type == TYPE_APP_SHORTCUT && delegate_->IsAppPinned(app_id)) ?
-      REMOVABLE : DRAGGABLE;
+  return (type == TYPE_APP_SHORTCUT && delegate_->IsAppPinned(app_id))
+             ? REMOVABLE
+             : DRAGGABLE;
 }
 
 bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
   switch (typea) {
     case TYPE_APP_SHORTCUT:
     case TYPE_BROWSER_SHORTCUT:
       return (typeb == TYPE_APP_SHORTCUT || typeb == TYPE_BROWSER_SHORTCUT);
     case TYPE_APP_LIST:
     case TYPE_PLATFORM_APP:
     case TYPE_WINDOWED_APP:
@@ skipping 146 matching lines @@
   if (at_end)
     return view_model_->view_size();
   return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
 }
 
 gfx::Size ShelfView::GetPreferredSize() const {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   const int shelf_size = GetShelfConstant(SHELF_SIZE);
 
-  int last_button_index = is_overflow_mode() ?
-      last_visible_index_ : view_model_->view_size() - 1;
+  int last_button_index =
+      is_overflow_mode() ? last_visible_index_ : view_model_->view_size() - 1;
 
   // When an item is dragged off from the overflow bubble, it is moved to last
   // position and and changed to invisible. Overflow bubble size should be
   // shrunk to fit only for visible items.
   // If |dragged_off_from_overflow_to_shelf_| is set, there will be no invisible
   // items in the shelf.
-  if (is_overflow_mode() &&
-      dragged_off_shelf_ &&
+  if (is_overflow_mode() && dragged_off_shelf_ &&
       !dragged_off_from_overflow_to_shelf_ &&
       RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
     last_button_index--;
 
   const gfx::Rect last_button_bounds =
       last_button_index >= first_visible_index_
           ? view_model_->ideal_bounds(last_button_index)
           : gfx::Rect(gfx::Size(shelf_size, shelf_size));
 
   if (shelf_->IsHorizontalAlignment())
@@ skipping 35 matching lines @@
 void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
   aura::Window* target_window = static_cast<views::View*>(event->target())
                                     ->GetWidget()
                                     ->GetNativeWindow();
   if (gesture_handler_.ProcessGestureEvent(*event, target_window))
     event->StopPropagation();
 }
 
 void ShelfView::ShelfItemAdded(int model_index) {
   {
-    base::AutoReset<bool> cancelling_drag(
-        &cancelling_drag_model_changed_, true);
+    base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
+                                          true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = CreateViewForItem(model_->items()[model_index]);
   AddChildView(view);
   // Hide the view, it'll be made visible when the animation is done. Using
   // opacity 0 here to avoid messing with CalculateIdealBounds which touches
   // the view's visibility.
   view->layer()->SetOpacity(0);
   view_model_->Add(view, model_index);
 
@@ skipping 17 matching lines @@
   } else {
     // Undo the hiding if animation does not run.
     view->layer()->SetOpacity(1.0f);
   }
 }
 
 void ShelfView::ShelfItemRemoved(int model_index, ShelfID id) {
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
   {
-    base::AutoReset<bool> cancelling_drag(
-        &cancelling_drag_model_changed_, true);
+    base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
+                                          true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = view_model_->view_at(model_index);
   view_model_->Remove(model_index);
 
   // When the overflow bubble is visible, the overflow range needs to be set
   // before CalculateIdealBounds() gets called. Otherwise CalculateIdealBounds()
   // could trigger a ShelfItemChanged() by hiding the overflow bubble and
   // since the overflow bubble is not yet synced with the ShelfModel this
   // could cause a crash.
   if (overflow_bubble_ && overflow_bubble_->IsShowing()) {
-    last_hidden_index_ = std::min(last_hidden_index_,
-                                  view_model_->view_size() - 1);
+    last_hidden_index_ =
+        std::min(last_hidden_index_, view_model_->view_size() - 1);
     UpdateOverflowRange(overflow_bubble_->shelf_view());
   }
 
   if (view->visible()) {
     // The first animation fades out the view. When done we'll animate the rest
     // of the views to their target location.
     bounds_animator_->AnimateViewTo(view, view->bounds());
     bounds_animator_->SetAnimationDelegate(
         view, std::unique_ptr<gfx::AnimationDelegate>(
                   new FadeOutAnimationDelegate(this, view)));
@@ skipping 25 matching lines @@
     view_model_->set_ideal_bounds(model_index, old_ideal_bounds);
     new_view->SetBoundsRect(old_view->bounds());
     if (overflow_button_ && overflow_button_->visible())
       AnimateToIdealBounds();
     return;
   }
 
   views::View* view = view_model_->view_at(model_index);
   switch (item.type) {
     case TYPE_BROWSER_SHORTCUT:
-      // Fallthrough for the new Shelf since it needs to show the activation
-      // change as well.
+    // Fallthrough for the new Shelf since it needs to show the activation
+    // change as well.
     case TYPE_APP_SHORTCUT:
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
     case TYPE_DIALOG:
     case TYPE_APP_PANEL:
     case TYPE_IME_MENU: {
       CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
       ShelfButton* button = static_cast<ShelfButton*>(view);
       ReflectItemStatus(item, button);
       button->SetImage(item.image);
@@ skipping 44 matching lines @@
       slowing_animations.reset(new ui::ScopedAnimationDurationScaleMode(
           ui::ScopedAnimationDurationScaleMode::SLOW_DURATION));
     }
 
     // Collect usage statistics before we decide what to do with the click.
     switch (model_->items()[last_pressed_index_].type) {
       case TYPE_APP_SHORTCUT:
       case TYPE_WINDOWED_APP:
       case TYPE_PLATFORM_APP:
       case TYPE_BROWSER_SHORTCUT:
-        WmShell::Get()->RecordUserMetricsAction(
-            UMA_LAUNCHER_CLICK_ON_APP);
+        WmShell::Get()->RecordUserMetricsAction(UMA_LAUNCHER_CLICK_ON_APP);
         break;
 
       case TYPE_APP_LIST:
         WmShell::Get()->RecordUserMetricsAction(
             UMA_LAUNCHER_CLICK_ON_APPLIST_BUTTON);
         break;
 
       case TYPE_APP_PANEL:
       case TYPE_DIALOG:
       case TYPE_IME_MENU:
@@ skipping 170 matching lines @@
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash