clang-format all of //ash

ash/shelf/shelf_widget.cc

 // Copyright 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_widget.h"
 
 #include "ash/aura/wm_shelf_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
@@ skipping 37 matching lines @@
 
 namespace ash {
 
 namespace {
 // Size of black border at bottom (or side) of shelf.
 const int kNumBlackPixels = 3;
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
-const int kTimeToDimMs = 3000;  // Slow in dimming.
+const int kTimeToDimMs = 3000;   // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
                    public views::WidgetDelegate,
                    BackgroundAnimatorDelegate {
  public:
   // If |disable_dimming_animations_for_test| is set, all alpha animations will
   // be performed instantly.
   DimmerView(ShelfWidget* shelf_widget,
@@ skipping 78 matching lines @@
       force_hovered_(false),
       disable_dimming_animations_for_test_(disable_dimming_animations_for_test),
       background_animator_(this, 0, kDimAlpha) {
   event_filter_.reset(new DimmerEventFilter(this));
   // Make sure it is undimmed at the beginning and then fire off the dimming
   // animation.
   background_animator_.SetPaintsBackground(false, BACKGROUND_CHANGE_IMMEDIATE);
   SetHovered(false);
 }
 
-DimmerView::~DimmerView() {
-}
+DimmerView::~DimmerView() {}
 
 void DimmerView::SetHovered(bool hovered) {
   // Remember the hovered state so that we can correct the state once a
   // possible force state has disappeared.
   is_hovered_ = hovered;
   // Undimm also if we were forced to by e.g. an open menu.
   hovered |= force_hovered_;
   background_animator_.SetDuration(hovered ? kTimeToUnDimMs : kTimeToDimMs);
   background_animator_.SetPaintsBackground(!hovered,
                                            disable_dimming_animations_for_test_
@@ skipping 21 matching lines @@
                               ? SkBitmapOperations::ROTATION_90_CW
                               : SkBitmapOperations::ROTATION_270_CW);
   }
   paint.setAlpha(alpha_);
   canvas->DrawImageInt(shelf_background, 0, 0, shelf_background.width(),
                        shelf_background.height(), 0, 0, width(), height(),
                        false, paint);
 }
 
 DimmerView::DimmerEventFilter::DimmerEventFilter(DimmerView* owner)
-    : owner_(owner),
-      mouse_inside_(false),
-      touch_inside_(false) {
+    : owner_(owner), mouse_inside_(false), touch_inside_(false) {
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 DimmerView::DimmerEventFilter::~DimmerEventFilter() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void DimmerView::DimmerEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_MOVED &&
       event->type() != ui::ET_MOUSE_DRAGGED)
@@ skipping 262 matching lines @@
     if (horizontal && dock_bounds.width() > 0) {
       // The part of the shelf background that is in the corner below the docked
       // windows close to the work area is an arched gradient that blends
       // vertically oriented docked background and horizontal shelf.
       gfx::ImageSkia shelf_corner =
           *rb->GetImageSkiaNamed(IDR_ASH_SHELF_CORNER);
       if (dock_bounds.x() == 0) {
         shelf_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
             shelf_corner, SkBitmapOperations::ROTATION_90_CW);
       }
-      canvas->DrawImageInt(
-          shelf_corner, 0, 0, shelf_corner.width(), shelf_corner.height(),
-          dock_bounds.x() > 0
-              ? dock_bounds.x()
-              : dock_bounds.width() - height(),
-          0, height(), height(), false, paint);
+      canvas->DrawImageInt(shelf_corner, 0, 0, shelf_corner.width(),
+                           shelf_corner.height(),
+                           dock_bounds.x() > 0 ? dock_bounds.x()
+                                               : dock_bounds.width() - height(),
+                           0, height(), height(), false, paint);
       // The part of the shelf background that is just below the docked windows
       // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
       // This avoids showing the border 3D shadow between the shelf and the
       // dock.
       canvas->DrawImageInt(shelf_background, 0, shelf_background.height() - 1,
                            shelf_background.width(), 1,
                            dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
                            0, dock_bounds.width() - height(), height(), false,
                            paint);
     }
@@ skipping 60 matching lines @@
 void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
   alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* wm_shelf_container,
                          WmWindow* wm_status_container,
                          WmShelfAura* wm_shelf_aura,
                          WorkspaceController* workspace_controller)
     : delegate_view_(new DelegateView(this)),
-      background_animator_(
-          delegate_view_, 0, GetShelfConstant(SHELF_BACKGROUND_ALPHA)),
+      background_animator_(delegate_view_,
+                           0,
+                           GetShelfConstant(SHELF_BACKGROUND_ALPHA)),
       activating_as_fallback_(false) {
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
   wm_shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           this, wm_shelf_container->GetShellWindowId(), &params);
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
   delegate_view_->SetParentLayer(GetLayer());
 
   shelf_layout_manager_ = new ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
   aura::Window* shelf_container =
       WmWindowAura::GetAuraWindow(wm_shelf_container);
   shelf_container->SetLayoutManager(shelf_layout_manager_);
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
   wm_shelf_aura->SetShelfLayoutManager(shelf_layout_manager_);
 
   // TODO(jamescook): Move ownership to RootWindowController.
   status_area_widget_ =
       new StatusAreaWidget(wm_status_container, wm_shelf_aura);
   status_area_widget_->CreateTrayViews();
-  if (Shell::GetInstance()->session_state_delegate()->
-          IsActiveUserSessionStarted()) {
+  if (Shell::GetInstance()
+          ->session_state_delegate()
+          ->IsActiveUserSessionStarted()) {
     status_area_widget_->Show();
   }
   WmShell::Get()->focus_cycler()->AddWidget(status_area_widget_);
 
   aura::Window* status_container =
       WmWindowAura::GetAuraWindow(wm_status_container);
   status_container->SetLayoutManager(
       new StatusAreaLayoutManager(status_container, this));
 
   shelf_container->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
@@ skipping 13 matching lines @@
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
   ui::Layer* opaque_background = delegate_view_->opaque_background();
   float target_opacity =
       (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
   std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
   if (change_type != BACKGROUND_CHANGE_IMMEDIATE) {
-    opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
-        opaque_background->GetAnimator()));
+    opaque_background_animation.reset(
+        new ui::ScopedLayerAnimationSettings(opaque_background->GetAnimator()));
     opaque_background_animation->SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
   }
   opaque_background->SetOpacity(target_opacity);
 
   // TODO(mukai): use ui::Layer on both opaque_background and normal background
   // retire background_animator_ at all. It would be simpler.
   // See also DockedBackgroundWidget::SetPaintsBackground.
   background_animator_.SetPaintsBackground(
       background_type != SHELF_BACKGROUND_DEFAULT, change_type);
 }
 
 ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
   if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
     return SHELF_BACKGROUND_MAXIMIZED;
   if (background_animator_.paints_background())
     return SHELF_BACKGROUND_OVERLAP;
 
   return SHELF_BACKGROUND_DEFAULT;
 }
 
 void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
   if (IsShelfHiddenBehindBlackBar() == hide)
     return;
 
   ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
   float target_opacity = hide ? 1.0f : 0.0f;
   std::unique_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
-  opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
-      opaque_foreground->GetAnimator()));
+  opaque_foreground_animation.reset(
+      new ui::ScopedLayerAnimationSettings(opaque_foreground->GetAnimator()));
   opaque_foreground_animation->SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(animation_time_ms));
   opaque_foreground_animation->SetPreemptionStrategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   opaque_foreground->SetOpacity(target_opacity);
 }
 
 bool ShelfWidget::IsShelfHiddenBehindBlackBar() const {
   return delegate_view_->opaque_foreground()->GetTargetOpacity() != 0.0f;
@@ skipping 147 matching lines @@
     shelf_layout_manager_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfWidget::OnGestureEvent(ui::GestureEvent* event) {
   Widget::OnGestureEvent(event);
   if (Shell::GetInstance()->in_mus() && shelf_layout_manager_)
     shelf_layout_manager_->UpdateAutoHideForGestureEvent(event);
 }
 
 }  // namespace ash