clang-format all of //ash

ash/shelf/overflow_bubble_view.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/shelf/overflow_bubble_view.h"
 
 #include <algorithm>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
@@ skipping 29 matching lines @@
 
 void OverflowBubbleView::InitOverflowBubble(views::View* anchor,
                                             ShelfView* shelf_view) {
   shelf_view_ = shelf_view;
 
   SetAnchorView(anchor);
   set_arrow(GetBubbleArrow());
   set_mirror_arrow_in_rtl(false);
   set_background(NULL);
   SkColor color = MaterialDesignController::IsShelfMaterial()
-      ? kShelfBaseColor
-      : SkColorSetA(kShelfBaseColor, GetShelfConstant(SHELF_BACKGROUND_ALPHA));
+                      ? kShelfBaseColor
+                      : SkColorSetA(kShelfBaseColor,
+                                    GetShelfConstant(SHELF_BACKGROUND_ALPHA));
   set_color(color);
   set_margins(gfx::Insets(kPadding, kPadding, kPadding, kPadding));
   // Overflow bubble should not get focus. If it get focus when it is shown,
   // active state item is changed to running state.
   set_can_activate(false);
 
   // Makes bubble view has a layer and clip its children layers.
   SetPaintToLayer(true);
   layer()->SetFillsBoundsOpaquely(false);
   layer()->SetMasksToBounds(true);
@@ skipping 44 matching lines @@
 
 gfx::Size OverflowBubbleView::GetPreferredSize() const {
   gfx::Size preferred_size = GetContentsSize();
 
   const gfx::Rect monitor_rect =
       display::Screen::GetScreen()
           ->GetDisplayNearestPoint(GetAnchorRect().CenterPoint())
           .work_area();
   if (!monitor_rect.IsEmpty()) {
     if (IsHorizontalAlignment()) {
-      preferred_size.set_width(std::min(
-          preferred_size.width(),
-          static_cast<int>(monitor_rect.width() *
-                           kMaxBubbleSizeToScreenRatio)));
+      preferred_size.set_width(
+          std::min(preferred_size.width(),
+                   static_cast<int>(monitor_rect.width() *
+                                    kMaxBubbleSizeToScreenRatio)));
     } else {
-      preferred_size.set_height(std::min(
-          preferred_size.height(),
-          static_cast<int>(monitor_rect.height() *
-                           kMaxBubbleSizeToScreenRatio)));
+      preferred_size.set_height(
+          std::min(preferred_size.height(),
+                   static_cast<int>(monitor_rect.height() *
+                                    kMaxBubbleSizeToScreenRatio)));
     }
   }
 
   return preferred_size;
 }
 
 void OverflowBubbleView::Layout() {
   shelf_view_->SetBoundsRect(gfx::Rect(
       gfx::PointAtOffsetFromOrigin(-scroll_offset_), GetContentsSize()));
 }
@@ skipping 33 matching lines @@
 }
 
 int OverflowBubbleView::GetDialogButtons() const {
   return ui::DIALOG_BUTTON_NONE;
 }
 
 gfx::Rect OverflowBubbleView::GetBubbleBounds() {
   views::BubbleBorder* border = GetBubbleFrameView()->bubble_border();
   gfx::Insets bubble_insets = border->GetInsets();
 
-  const int border_size =
-      views::BubbleBorder::is_arrow_on_horizontal(arrow()) ?
-      bubble_insets.left() : bubble_insets.top();
+  const int border_size = views::BubbleBorder::is_arrow_on_horizontal(arrow())
+                              ? bubble_insets.left()
+                              : bubble_insets.top();
   const int arrow_offset = border_size + kPadding + kShelfViewLeadingInset +
                            GetShelfConstant(SHELF_SIZE) / 2;
 
   const gfx::Size content_size = GetPreferredSize();
   border->set_arrow_offset(arrow_offset);
 
   const gfx::Rect anchor_rect = GetAnchorRect();
   gfx::Rect bubble_rect = GetBubbleFrameView()->GetUpdatedWindowBounds(
-      anchor_rect,
-      content_size,
-      false);
+      anchor_rect, content_size, false);
 
   gfx::Rect monitor_rect =
       display::Screen::GetScreen()
           ->GetDisplayNearestPoint(anchor_rect.CenterPoint())
           .work_area();
 
   int offset = 0;
   if (views::BubbleBorder::is_arrow_on_horizontal(arrow())) {
     if (bubble_rect.x() < monitor_rect.x())
       offset = monitor_rect.x() - bubble_rect.x();
     else if (bubble_rect.right() > monitor_rect.right())
       offset = monitor_rect.right() - bubble_rect.right();
 
     bubble_rect.Offset(offset, 0);
     border->set_arrow_offset(anchor_rect.CenterPoint().x() - bubble_rect.x());
   } else {
     if (bubble_rect.y() < monitor_rect.y())
       offset = monitor_rect.y() - bubble_rect.y();
     else if (bubble_rect.bottom() > monitor_rect.bottom())
-      offset =  monitor_rect.bottom() - bubble_rect.bottom();
+      offset = monitor_rect.bottom() - bubble_rect.bottom();
 
     bubble_rect.Offset(0, offset);
     border->set_arrow_offset(anchor_rect.CenterPoint().y() - bubble_rect.y());
   }
 
   GetBubbleFrameView()->SchedulePaint();
   return bubble_rect;
 }
 
 }  // namespace ash