clang-format all of //ash

ash/shelf/shelf_layout_manager.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_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
@@ skipping 95 matching lines @@
   void OnGestureEvent(ui::GestureEvent* event) override;
 
  private:
   ShelfLayoutManager* shelf_;
   bool in_mouse_drag_;
   DISALLOW_COPY_AND_ASSIGN(AutoHideEventFilter);
 };
 
 ShelfLayoutManager::AutoHideEventFilter::AutoHideEventFilter(
     ShelfLayoutManager* shelf)
-    : shelf_(shelf),
-      in_mouse_drag_(false) {
+    : shelf_(shelf), in_mouse_drag_(false) {
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 ShelfLayoutManager::AutoHideEventFilter::~AutoHideEventFilter() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
   // This also checks IsShelfWindow() to make sure we don't attempt to hide the
   // shelf if the mouse down occurs on the shelf.
-  in_mouse_drag_ = (event->type() == ui::ET_MOUSE_DRAGGED ||
-                    (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
-                     event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
+  in_mouse_drag_ =
+      (event->type() == ui::ET_MOUSE_DRAGGED ||
+       (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
+        event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
       !shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()));
   shelf_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   shelf_->UpdateAutoHideForGestureEvent(event);
 }
 
 // ShelfLayoutManager:UpdateShelfObserver --------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
-  void Detach() {
-    shelf_ = NULL;
-  }
+  void Detach() { shelf_ = NULL; }
 
   void OnImplicitAnimationsCompleted() override {
     if (shelf_)
       shelf_->UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
     delete this;
   }
 
  private:
   ~UpdateShelfObserver() override {
     if (shelf_)
@@ skipping 65 matching lines @@
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillDeleteShelfLayoutManager());
   WmShell::Get()->RemoveShellObserver(this);
   Shell::GetInstance()->lock_state_controller()->RemoveObserver(this);
-  Shell::GetInstance()->
-      session_state_delegate()->RemoveSessionStateObserver(this);
+  Shell::GetInstance()->session_state_delegate()->RemoveSessionStateObserver(
+      this);
   if (root_window_controller_observer_) {
     WmWindowAura::Get(root_window_)
         ->GetRootWindowController()
         ->RemoveObserver(root_window_controller_observer_.get());
   }
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   in_shutdown_ = true;
   // Clear all event filters, otherwise sometimes those filters may catch
@@ skipping 64 matching lines @@
     SetState(SHELF_VISIBLE);
   } else if (WmShell::Get()->IsPinned()) {
     SetState(SHELF_HIDDEN);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
     wm::WorkspaceWindowState window_state(
         workspace_controller_->GetWindowState());
     switch (window_state) {
       case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
-        const aura::Window* fullscreen_window = GetRootWindowController(
-            root_window_)->GetWindowForFullscreenMode();
-        if (fullscreen_window && wm::GetWindowState(fullscreen_window)->
-                hide_shelf_when_fullscreen()) {
+        const aura::Window* fullscreen_window =
+            GetRootWindowController(root_window_)->GetWindowForFullscreenMode();
+        if (fullscreen_window &&
+            wm::GetWindowState(fullscreen_window)
+                ->hide_shelf_when_fullscreen()) {
           SetState(SHELF_HIDDEN);
         } else {
           // The shelf is sometimes not hidden when in immersive fullscreen.
           // Force the shelf to be auto hidden in this case.
           SetState(SHELF_AUTO_HIDE);
         }
         break;
       }
 
       case wm::WORKSPACE_WINDOW_STATE_MAXIMIZED:
@@ skipping 17 matching lines @@
     if (auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
       // Hides happen immediately.
       SetState(state_.visibility_state);
     } else {
       if (!auto_hide_timer_.IsRunning()) {
         mouse_over_shelf_when_auto_hide_timer_started_ =
             shelf_widget_->GetWindowBoundsInScreen().Contains(
                 display::Screen::GetScreen()->GetCursorScreenPoint());
       }
       auto_hide_timer_.Start(
-          FROM_HERE,
-          base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
-          this, &ShelfLayoutManager::UpdateAutoHideStateNow);
+          FROM_HERE, base::TimeDelta::FromMilliseconds(kAutoHideDelayMS), this,
+          &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideForMouseEvent(ui::MouseEvent* event) {
   // Don't update during shutdown because synthetic mouse events (e.g. mouse
   // exit) may be generated during status area widget teardown.
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
@@ skipping 39 matching lines @@
     gesture_drag_auto_hide_state_ = SHELF_AUTO_HIDE_SHOWN;
     gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
     UpdateVisibilityState();
     gesture_drag_status_ = GESTURE_DRAG_NONE;
   }
 }
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
-  gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE ?
-      auto_hide_state() : SHELF_AUTO_HIDE_SHOWN;
+  gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE
+                                      ? auto_hide_state()
+                                      : SHELF_AUTO_HIDE_SHOWN;
   UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
 }
 
 void ShelfLayoutManager::UpdateGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_amount_ += PrimaryAxisValue(gesture.details().scroll_y(),
                                            gesture.details().scroll_x());
   LayoutShelf();
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
@@ skipping 18 matching lines @@
           correct_direction = gesture_drag_amount_ < 0;
           break;
         case SHELF_ALIGNMENT_LEFT:
           correct_direction = gesture_drag_amount_ > 0;
           break;
       }
       should_change = correct_direction && drag_ratio > kDragHideThreshold;
     }
   } else if (gesture.type() == ui::ET_SCROLL_FLING_START) {
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
-      should_change = horizontal ? fabs(gesture.details().velocity_y()) > 0 :
-                                   fabs(gesture.details().velocity_x()) > 0;
+      should_change = horizontal ? fabs(gesture.details().velocity_y()) > 0
+                                 : fabs(gesture.details().velocity_x()) > 0;
     } else {
       should_change =
           SelectValueForShelfAlignment(gesture.details().velocity_y() < 0,
                                        gesture.details().velocity_x() > 0,
                                        gesture.details().velocity_x() < 0);
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
   if (shelf_widget_) {
     shelf_widget_->Deactivate();
     shelf_widget_->status_area_widget()->Deactivate();
   }
   gesture_drag_auto_hide_state_ =
-      gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN ?
-      SHELF_AUTO_HIDE_HIDDEN : SHELF_AUTO_HIDE_SHOWN;
+      gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN
+          ? SHELF_AUTO_HIDE_HIDDEN
+          : SHELF_AUTO_HIDE_SHOWN;
   ShelfAutoHideBehavior new_auto_hide_behavior =
-      gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN ?
-      SHELF_AUTO_HIDE_BEHAVIOR_NEVER : SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
+      gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN
+          ? SHELF_AUTO_HIDE_BEHAVIOR_NEVER
+          : SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
 
   // When in fullscreen and the shelf is forced to be auto hidden, the auto hide
   // behavior affects neither the visibility state nor the auto hide state. Set
   // |gesture_drag_status_| to GESTURE_DRAG_COMPLETE_IN_PROGRESS to set the auto
   // hide state to |gesture_drag_auto_hide_state_|.
   gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
   Shelf* shelf = shelf_widget_->shelf();
   if (shelf->auto_hide_behavior() != new_auto_hide_behavior)
     shelf->SetAutoHideBehavior(new_auto_hide_behavior);
   else
@@ skipping 151 matching lines @@
   } else {
     UpdateShelfBackground(change_type);
   }
 
   shelf_widget_->SetDimsShelf(state.visibility_state == SHELF_VISIBLE &&
                               state.window_state ==
                                   wm::WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, true,
-      delay_background_change ? update_shelf_observer_ : NULL);
+  UpdateBoundsAndOpacity(target_bounds, true, delay_background_change
+                                                  ? update_shelf_observer_
+                                                  : NULL);
 
   // The delegate must be notified after |state_| is updated so that it can
   // query the new target bounds.
   ShelfDelegate* shelf_delegate = Shell::GetInstance()->GetShelfDelegate();
   if (old_state.visibility_state != state_.visibility_state)
     shelf_delegate->OnShelfVisibilityStateChanged(shelf_widget_->shelf());
 
   // OnAutoHideStateChanged Should be emitted when:
   //  - firstly state changed to auto-hide from other state
   //  - or, auto_hide_state has changed
@@ skipping 10 matching lines @@
     const TargetBounds& target_bounds,
     bool animate,
     ui::ImplicitAnimationObserver* observer) {
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
   {
     ui::ScopedLayerAnimationSettings shelf_animation_setter(
         GetLayer(shelf_widget_)->GetAnimator());
     ui::ScopedLayerAnimationSettings status_animation_setter(
         GetLayer(shelf_widget_->status_area_widget())->GetAnimator());
     if (animate) {
-      int duration = duration_override_in_ms_ ? duration_override_in_ms_ :
-                                                kCrossFadeDurationMS;
+      int duration = duration_override_in_ms_ ? duration_override_in_ms_
+                                              : kCrossFadeDurationMS;
       shelf_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       shelf_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       shelf_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       status_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       status_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       status_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 97 matching lines @@
       gfx::Rect(shelf_origin.x(), shelf_origin.y(), shelf_width, shelf_height);
 
   gfx::Size status_size(
       shelf_widget_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
     status_size.set_height(GetShelfConstant(SHELF_SIZE));
   else
     status_size.set_width(GetShelfConstant(SHELF_SIZE));
 
   gfx::Point status_origin = SelectValueForShelfAlignment(
-      gfx::Point(0, 0),
-      gfx::Point(shelf_width - status_size.width(),
-                 shelf_height - status_size.height()),
+      gfx::Point(0, 0), gfx::Point(shelf_width - status_size.width(),
+                                   shelf_height - status_size.height()),
       gfx::Point(0, shelf_height - status_size.height()));
   if (IsHorizontalAlignment() && !base::i18n::IsRTL())
     status_origin.set_x(shelf_width - status_size.width());
   target_bounds->status_bounds_in_shelf = gfx::Rect(status_origin, status_size);
 
   target_bounds->work_area_insets = SelectValueForShelfAlignment(
       gfx::Insets(0, 0, GetWorkAreaInsets(state, shelf_height), 0),
       gfx::Insets(0, GetWorkAreaInsets(state, shelf_width), 0, 0),
       gfx::Insets(0, 0, 0, GetWorkAreaInsets(state, shelf_width)));
 
   // TODO(varkha): The functionality of managing insets for display areas
   // should probably be pushed to a separate component. This would simplify or
   // remove entirely the dependency on keyboard and dock.
 
   if (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()) {
     // Also push in the work area inset for the keyboard if it is visible.
     gfx::Insets keyboard_insets(0, 0, keyboard_bounds_.height(), 0);
     target_bounds->work_area_insets += keyboard_insets;
   }
 
   // Also push in the work area inset for the dock if it is visible.
   if (!dock_bounds_.IsEmpty()) {
     gfx::Insets dock_insets(
-        0, (dock_bounds_.x() > 0 ? 0 : dock_bounds_.width()),
-        0, (dock_bounds_.x() > 0 ? dock_bounds_.width() : 0));
+        0, (dock_bounds_.x() > 0 ? 0 : dock_bounds_.width()), 0,
+        (dock_bounds_.x() > 0 ? dock_bounds_.width() : 0));
     target_bounds->work_area_insets += dock_insets;
   }
 
   // Also push in the work area insets for the ChromeVox panel if it's visible.
   if (chromevox_panel_height_) {
     gfx::Insets chromevox_insets(chromevox_panel_height_, 0, 0, 0);
     target_bounds->work_area_insets += chromevox_insets;
   }
 
   target_bounds->opacity = ComputeTargetOpacity(state);
   target_bounds->status_opacity =
       (state.visibility_state == SHELF_AUTO_HIDE &&
        state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
-       gesture_drag_status_ != GESTURE_DRAG_IN_PROGRESS) ?
-      0.0f : target_bounds->opacity;
+       gesture_drag_status_ != GESTURE_DRAG_IN_PROGRESS)
+          ? 0.0f
+          : target_bounds->opacity;
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 
   // This needs to happen after calling UpdateTargetBoundsForGesture(), because
   // that can change the size of the shelf.
   target_bounds->shelf_bounds_in_shelf = SelectValueForShelfAlignment(
       gfx::Rect(0, 0, shelf_width - status_size.width(),
                 target_bounds->shelf_bounds_in_root.height()),
       gfx::Rect(0, 0, target_bounds->shelf_bounds_in_root.width(),
@@ skipping 19 matching lines @@
       visibility_state() == SHELF_AUTO_HIDE &&
       auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
     resistance_free_region = GetShelfConstant(SHELF_SIZE) - kShelfAutoHideSize;
   }
 
   bool resist = SelectValueForShelfAlignment(
-      gesture_drag_amount_ < -resistance_free_region,
-      gesture_drag_amount_ > resistance_free_region,
+      gesture_drag_amount_<-resistance_free_region, gesture_drag_amount_>
+          resistance_free_region,
       gesture_drag_amount_ < -resistance_free_region);
 
   float translate = 0.f;
   if (resist) {
     float diff = fabsf(gesture_drag_amount_) - resistance_free_region;
     diff = std::min(diff, sqrtf(diff));
     if (gesture_drag_amount_ < 0)
       translate = -resistance_free_region - diff;
     else
       translate = resistance_free_region + diff;
   } else {
     translate = gesture_drag_amount_;
   }
   int shelf_insets = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   if (horizontal) {
     // Move and size the shelf with the gesture.
     int shelf_height = target_bounds->shelf_bounds_in_root.height() - translate;
     shelf_height = std::max(shelf_height, shelf_insets);
     target_bounds->shelf_bounds_in_root.set_height(shelf_height);
     if (IsHorizontalAlignment()) {
-      target_bounds->shelf_bounds_in_root.set_y(
-          available_bounds.bottom() - shelf_height);
+      target_bounds->shelf_bounds_in_root.set_y(available_bounds.bottom() -
+                                                shelf_height);
     }
 
     target_bounds->status_bounds_in_shelf.set_y(0);
   } else {
     // Move and size the shelf with the gesture.
     int shelf_width = target_bounds->shelf_bounds_in_root.width();
     bool right_aligned = GetAlignment() == SHELF_ALIGNMENT_RIGHT;
     if (right_aligned)
       shelf_width -= translate;
     else
       shelf_width += translate;
     shelf_width = std::max(shelf_width, shelf_insets);
     target_bounds->shelf_bounds_in_root.set_width(shelf_width);
     if (right_aligned) {
-      target_bounds->shelf_bounds_in_root.set_x(
-          available_bounds.right() - shelf_width);
+      target_bounds->shelf_bounds_in_root.set_x(available_bounds.right() -
+                                                shelf_width);
     }
 
     if (right_aligned) {
       target_bounds->status_bounds_in_shelf.set_x(0);
     } else {
       target_bounds->status_bounds_in_shelf.set_x(
           target_bounds->shelf_bounds_in_root.width() -
           GetShelfConstant(SHELF_SIZE));
     }
   }
@@ skipping 256 matching lines @@
   if (ash::MaterialDesignController::IsShelfMaterial()) {
     return (state.visibility_state == SHELF_AUTO_HIDE &&
             state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)
                ? 1.0f
                : 0.0f;
   }
   return (state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
 }
 
 }  // namespace ash