clang-format all of //ash

ash/common/system/tray/tray_background_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/common/system/tray/tray_background_view.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
@@ skipping 42 matching lines @@
 
 namespace ash {
 
 // static
 const char TrayBackgroundView::kViewClassName[] = "tray/TrayBackgroundView";
 
 // Used to track when the anchor widget changes position on screen so that the
 // bubble position can be updated.
 class TrayBackgroundView::TrayWidgetObserver : public views::WidgetObserver {
  public:
-  explicit TrayWidgetObserver(TrayBackgroundView* host)
-      : host_(host) {
-  }
+  explicit TrayWidgetObserver(TrayBackgroundView* host) : host_(host) {}
 
   void OnWidgetBoundsChanged(views::Widget* widget,
                              const gfx::Rect& new_bounds) override {
     host_->AnchorUpdated();
   }
 
   void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override {
     host_->AnchorUpdated();
   }
 
  private:
   TrayBackgroundView* host_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayWidgetObserver);
 };
 
 class TrayBackground : public views::Background {
  public:
   const static int kImageTypeDefault = 0;
   const static int kImageTypeOnBlack = 1;
   const static int kImageTypePressed = 2;
   const static int kNumStates = 3;
 
   const static int kImageHorizontal = 0;
   const static int kImageVertical = 1;
   const static int kNumOrientations = 2;
 
-  explicit TrayBackground(TrayBackgroundView* tray_background_view) :
-      tray_background_view_(tray_background_view) {
-  }
+  explicit TrayBackground(TrayBackgroundView* tray_background_view)
+      : tray_background_view_(tray_background_view) {}
 
   ~TrayBackground() override {}
 
  private:
   WmShelf* GetShelf() const { return tray_background_view_->shelf(); }
 
   void PaintMaterial(gfx::Canvas* canvas, views::View* view) const {
     SkColor background_color = SK_ColorTRANSPARENT;
     if (GetShelf()->GetBackgroundType() ==
         ShelfBackgroundType::SHELF_BACKGROUND_DEFAULT) {
@@ skipping 16 matching lines @@
       highlight_paint.setFlags(SkPaint::kAntiAlias_Flag);
       highlight_paint.setColor(kShelfButtonActivatedHighlightColor);
       canvas->DrawRoundRect(view->GetLocalBounds(), kCornerRadius,
                             highlight_paint);
     }
   }
 
   void PaintNonMaterial(gfx::Canvas* canvas, views::View* view) const {
     const int kGridSizeForPainter = 9;
     const int kImages[kNumOrientations][kNumStates][kGridSizeForPainter] = {
-      { // Horizontal
-        IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ),
-        IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_ONBLACK),
-        IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_PRESSED),
-      },
-      { // Vertical
-        IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL),
-        IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_ONBLACK),
-        IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_PRESSED),
-      }
-    };
+        {
+            // Horizontal
+            IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ),
+            IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_ONBLACK),
+            IMAGE_GRID_HORIZONTAL(IDR_AURA_TRAY_BG_HORIZ_PRESSED),
+        },
+        {
+            // Vertical
+            IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL),
+            IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_ONBLACK),
+            IMAGE_GRID_VERTICAL(IDR_AURA_TRAY_BG_VERTICAL_PRESSED),
+        }};
 
     WmShelf* shelf = GetShelf();
     const int orientation = IsHorizontalAlignment(shelf->GetAlignment())
                                 ? kImageHorizontal
                                 : kImageVertical;
 
     int state = kImageTypeDefault;
     if (tray_background_view_->draw_background_as_active())
       state = kImageTypePressed;
     else if (shelf->IsDimmed())
@@ skipping 129 matching lines @@
     views::View::SetVisible(true);
     // If SetVisible(true) is called while animating to not visible, then
     // views::View::SetVisible(true) is a no-op. When the previous animation
     // ends layer->SetVisible(false) is called. To prevent this
     // layer->SetVisible(true) immediately interrupts the animation of this
     // property, and keeps the layer visible.
     layer()->SetVisible(true);
   }
 
   ui::ScopedLayerAnimationSettings animation(layer()->GetAnimator());
-  animation.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
-      kAnimationDurationForVisibilityMs));
+  animation.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kAnimationDurationForVisibilityMs));
   animation.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   if (visible) {
     animation.SetTweenType(gfx::Tween::EASE_OUT);
     // Show is delayed so as to allow time for other children of
     // StatusAreaWidget to begin animating to their new positions.
     layer()->GetAnimator()->SchedulePauseForProperties(
         base::TimeDelta::FromMilliseconds(kShowAnimationDelayMs),
         ui::LayerAnimationElement::OPACITY |
-        ui::LayerAnimationElement::TRANSFORM);
+            ui::LayerAnimationElement::TRANSFORM);
     layer()->SetOpacity(1.0f);
     gfx::Transform transform;
     transform.Translate(0.0f, 0.0f);
     layer()->SetTransform(transform);
   } else {
     // Listen only to the hide animation. As we cannot turn off visibility
     // until the animation is over.
     animation.AddObserver(this);
     animation.SetTweenType(gfx::Tween::EASE_IN);
     layer()->SetOpacity(0.0f);
@@ skipping 30 matching lines @@
   // The tray itself expands to the right and bottom edge of the screen to make
   // sure clicking on the edges brings up the popup. However, the focus border
   // should be only around the container.
   return GetContentsBounds();
 }
 
 void TrayBackgroundView::OnGestureEvent(ui::GestureEvent* event) {
   if (switches::IsTouchFeedbackEnabled()) {
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       SetDrawBackgroundAsActive(true);
-    } else if (event->type() ==  ui::ET_GESTURE_SCROLL_BEGIN ||
-               event->type() ==  ui::ET_GESTURE_TAP_CANCEL) {
+    } else if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
+               event->type() == ui::ET_GESTURE_TAP_CANCEL) {
       SetDrawBackgroundAsActive(false);
     }
   }
   ActionableView::OnGestureEvent(event);
 }
 
 void TrayBackgroundView::UpdateBackground(int alpha) {
   // The animator should never fire when the alternate shelf layout is used.
   if (!background_ || draw_background_as_active_)
     return;
@@ skipping 14 matching lines @@
   tray_container_->SetAlignment(alignment);
 }
 
 void TrayBackgroundView::OnImplicitAnimationsCompleted() {
   // If there is another animation in the queue, the reverse animation was
   // triggered before the completion of animating to invisible. Do not turn off
   // the visibility so that the next animation may render. The value of
   // layer()->GetTargetVisibility() can be incorrect if the hide animation was
   // aborted to schedule an animation to become visible. As the new animation
   // is not yet added to the queue. crbug.com/374236
-  if(layer()->GetAnimator()->is_animating() ||
-     layer()->GetTargetVisibility())
+  if (layer()->GetAnimator()->is_animating() || layer()->GetTargetVisibility())
     return;
   views::View::SetVisible(false);
 }
 
 bool TrayBackgroundView::RequiresNotificationWhenAnimatorDestroyed() const {
   // This is needed so that OnImplicitAnimationsCompleted() is called even upon
   // destruction of the animator. This can occure when parallel animations
   // caused by ScreenRotationAnimator end before the animations of
   // TrayBackgroundView. This allows for a proper update to the visual state of
   // the view. (crbug.com/476667)
@@ skipping 12 matching lines @@
 gfx::Rect TrayBackgroundView::GetBubbleAnchorRect(
     views::Widget* anchor_widget,
     TrayBubbleView::AnchorType anchor_type,
     TrayBubbleView::AnchorAlignment anchor_alignment) const {
   gfx::Rect rect;
   if (anchor_widget && anchor_widget->IsVisible()) {
     rect = anchor_widget->GetWindowBoundsInScreen();
     if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
         bool rtl = base::i18n::IsRTL();
-        rect.Inset(
-            rtl ? kBubblePaddingHorizontalSide : 0,
-            kBubblePaddingHorizontalBottom,
-            rtl ? 0 : kBubblePaddingHorizontalSide,
-            0);
+        rect.Inset(rtl ? kBubblePaddingHorizontalSide : 0,
+                   kBubblePaddingHorizontalBottom,
+                   rtl ? 0 : kBubblePaddingHorizontalSide, 0);
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
         rect.Inset(0, 0, kBubblePaddingVerticalSide + 4,
                    kBubblePaddingVerticalBottom);
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
         rect.Inset(kBubblePaddingVerticalSide, 0, 0,
                    kBubblePaddingVerticalBottom);
       } else {
         // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
         // ie. ANCHOR_ALIGNMENT_TOP
         DCHECK(false) << "Unhandled anchor alignment.";
@@ skipping 14 matching lines @@
   } else {
     WmWindow* target_root = anchor_widget
                                 ? WmLookup::Get()
                                       ->GetWindowForWidget(anchor_widget)
                                       ->GetRootWindow()
                                 : WmShell::Get()->GetPrimaryRootWindow();
     rect = target_root->GetBounds();
     if (anchor_type == TrayBubbleView::ANCHOR_TYPE_TRAY) {
       if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM) {
         rect = gfx::Rect(
-            base::i18n::IsRTL() ?
-            kPaddingFromRightEdgeOfScreenBottomAlignment :
-            rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
-            0, 0);
+            base::i18n::IsRTL()
+                ? kPaddingFromRightEdgeOfScreenBottomAlignment
+                : rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 0, 0);
         rect = target_root->ConvertRectToScreen(rect);
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_LEFT) {
         rect = gfx::Rect(
             kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
-            1, 1);
+            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 1, 1);
         rect = target_root->ConvertRectToScreen(rect);
       } else if (anchor_alignment == TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT) {
         rect = gfx::Rect(
             rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-            rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
-            1, 1);
+            rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 1, 1);
         rect = target_root->ConvertRectToScreen(rect);
       } else {
         // TODO(bruthig) May need to handle other ANCHOR_ALIGNMENT_ values.
         // ie. ANCHOR_ALIGNMENT_TOP
         DCHECK(false) << "Unhandled anchor alignment.";
       }
     } else {
       rect = gfx::Rect(
-          base::i18n::IsRTL() ?
-          kPaddingFromRightEdgeOfScreenBottomAlignment :
-          rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
-          rect.height() - kPaddingFromBottomOfScreenBottomAlignment,
-          0, 0);
+          base::i18n::IsRTL()
+              ? kPaddingFromRightEdgeOfScreenBottomAlignment
+              : rect.width() - kPaddingFromRightEdgeOfScreenBottomAlignment,
+          rect.height() - kPaddingFromBottomOfScreenBottomAlignment, 0, 0);
     }
   }
   return rect;
 }
 
 TrayBubbleView::AnchorAlignment TrayBackgroundView::GetAnchorAlignment() const {
   if (shelf_alignment_ == SHELF_ALIGNMENT_LEFT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_LEFT;
   if (shelf_alignment_ == SHELF_ALIGNMENT_RIGHT)
     return TrayBubbleView::ANCHOR_ALIGNMENT_RIGHT;
   return TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
 }
 
 void TrayBackgroundView::SetDrawBackgroundAsActive(bool visible) {
   if (draw_background_as_active_ == visible)
     return;
   draw_background_as_active_ = visible;
   if (!background_)
     return;
   SchedulePaint();
 }
 
 void TrayBackgroundView::UpdateBubbleViewArrow(
     views::TrayBubbleView* bubble_view) {
   // Nothing to do here.
 }
 
 }  // namespace ash