clang-format all of //ash

ash/frame/caption_buttons/frame_size_button.cc

 // Copyright 2014 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/frame/caption_buttons/frame_size_button.h"
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
@@ skipping 28 matching lines @@
   gfx::Rect expanded_bounds_in_screen = button->GetBoundsInScreen();
   if (button->state() == views::Button::STATE_HOVERED ||
       button->state() == views::Button::STATE_PRESSED) {
     expanded_bounds_in_screen.Inset(-kMaxOvershootX, -kMaxOvershootY);
   }
   return expanded_bounds_in_screen.Contains(location_in_screen);
 }
 
 }  // namespace
 
-FrameSizeButton::FrameSizeButton(
-    views::ButtonListener* listener,
-    views::Widget* frame,
-    FrameSizeButtonDelegate* delegate)
+FrameSizeButton::FrameSizeButton(views::ButtonListener* listener,
+                                 views::Widget* frame,
+                                 FrameSizeButtonDelegate* delegate)
     : FrameCaptionButton(listener, CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE),
       frame_(frame),
       delegate_(delegate),
       set_buttons_to_snap_mode_delay_ms_(kSetButtonsToSnapModeDelayMs),
       in_snap_mode_(false),
-      snap_type_(SNAP_NONE) {
-}
+      snap_type_(SNAP_NONE) {}
 
-FrameSizeButton::~FrameSizeButton() {
-}
+FrameSizeButton::~FrameSizeButton() {}
 
 bool FrameSizeButton::OnMousePressed(const ui::MouseEvent& event) {
   // The minimize and close buttons are set to snap left and right when snapping
   // is enabled. Do not enable snapping if the minimize button is not visible.
   // The close button is always visible.
-  if (IsTriggerableEvent(event) &&
-      !in_snap_mode_ &&
+  if (IsTriggerableEvent(event) && !in_snap_mode_ &&
       delegate_->IsMinimizeButtonVisible()) {
     StartSetButtonsToSnapModeTimer(event);
   }
   FrameCaptionButton::OnMousePressed(event);
   return true;
 }
 
 bool FrameSizeButton::OnMouseDragged(const ui::MouseEvent& event) {
   UpdateSnapType(event);
   // By default a FrameCaptionButton reverts to STATE_NORMAL once the mouse
@@ skipping 55 matching lines @@
 
 void FrameSizeButton::StartSetButtonsToSnapModeTimer(
     const ui::LocatedEvent& event) {
   set_buttons_to_snap_mode_timer_event_location_ = event.location();
   if (set_buttons_to_snap_mode_delay_ms_ == 0) {
     AnimateButtonsToSnapMode();
   } else {
     set_buttons_to_snap_mode_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(set_buttons_to_snap_mode_delay_ms_),
-        this,
-        &FrameSizeButton::AnimateButtonsToSnapMode);
+        this, &FrameSizeButton::AnimateButtonsToSnapMode);
   }
 }
 
 void FrameSizeButton::AnimateButtonsToSnapMode() {
   SetButtonsToSnapMode(FrameSizeButtonDelegate::ANIMATE_YES);
 }
 
 void FrameSizeButton::SetButtonsToSnapMode(
     FrameSizeButtonDelegate::Animate animate) {
   in_snap_mode_ = true;
 
   // When using a right-to-left layout the close button is left of the size
   // button and the minimize button is right of the size button.
   if (base::i18n::IsRTL()) {
     delegate_->SetButtonIcons(CAPTION_BUTTON_ICON_RIGHT_SNAPPED,
-                              CAPTION_BUTTON_ICON_LEFT_SNAPPED,
-                              animate);
+                              CAPTION_BUTTON_ICON_LEFT_SNAPPED, animate);
   } else {
     delegate_->SetButtonIcons(CAPTION_BUTTON_ICON_LEFT_SNAPPED,
-                              CAPTION_BUTTON_ICON_RIGHT_SNAPPED,
-                              animate);
+                              CAPTION_BUTTON_ICON_RIGHT_SNAPPED, animate);
   }
 }
 
 void FrameSizeButton::UpdateSnapType(const ui::LocatedEvent& event) {
   if (!in_snap_mode_) {
     // Set the buttons adjacent to the size button to snap left and right early
     // if the user drags past the drag threshold.
     // |set_buttons_to_snap_mode_timer_| is checked to avoid entering the snap
     // mode as a result of an unsupported drag type (e.g. only the right mouse
     // button is pressed).
-    gfx::Vector2d delta(
-        event.location() - set_buttons_to_snap_mode_timer_event_location_);
+    gfx::Vector2d delta(event.location() -
+                        set_buttons_to_snap_mode_timer_event_location_);
     if (!set_buttons_to_snap_mode_timer_.IsRunning() ||
         !views::View::ExceededDragThreshold(delta)) {
       return;
     }
     AnimateButtonsToSnapMode();
   }
 
   gfx::Point event_location_in_screen(event.location());
   views::View::ConvertPointToScreen(this, &event_location_in_screen);
   const FrameCaptionButton* to_hover =
       GetButtonToHover(event_location_in_screen);
   bool press_size_button =
       to_hover || HitTestButton(this, event_location_in_screen);
 
   if (to_hover) {
     // Progress the minimize and close icon morph animations to the end if they
     // are in progress.
     SetButtonsToSnapMode(FrameSizeButtonDelegate::ANIMATE_NO);
   }
 
-  delegate_->SetHoveredAndPressedButtons(
-      to_hover, press_size_button ? this : NULL);
+  delegate_->SetHoveredAndPressedButtons(to_hover,
+                                         press_size_button ? this : NULL);
 
   snap_type_ = SNAP_NONE;
   if (to_hover) {
     switch (to_hover->icon()) {
       case CAPTION_BUTTON_ICON_LEFT_SNAPPED:
         snap_type_ = SNAP_LEFT;
         break;
       case CAPTION_BUTTON_ICON_RIGHT_SNAPPED:
         snap_type_ = SNAP_RIGHT;
         break;
@@ skipping 22 matching lines @@
                   WmWindowAura::Get(window));
     phantom_window_controller_->Show(ScreenUtil::ConvertRectToScreen(
         window->parent(), phantom_bounds_in_parent));
   } else {
     phantom_window_controller_.reset();
   }
 }
 
 const FrameCaptionButton* FrameSizeButton::GetButtonToHover(
     const gfx::Point& event_location_in_screen) const {
-  const FrameCaptionButton* closest_button = delegate_->GetButtonClosestTo(
-      event_location_in_screen);
+  const FrameCaptionButton* closest_button =
+      delegate_->GetButtonClosestTo(event_location_in_screen);
   if ((closest_button->icon() == CAPTION_BUTTON_ICON_LEFT_SNAPPED ||
        closest_button->icon() == CAPTION_BUTTON_ICON_RIGHT_SNAPPED) &&
       HitTestButton(closest_button, event_location_in_screen)) {
     return closest_button;
   }
   return NULL;
 }
 
 bool FrameSizeButton::CommitSnap(const ui::LocatedEvent& event) {
   // The position of |event| may be different than the position of the previous
   // event.
   UpdateSnapType(event);
 
-  if (in_snap_mode_ &&
-      (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
+  if (in_snap_mode_ && (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
     wm::WindowState* window_state =
         wm::GetWindowState(frame_->GetNativeWindow());
-    const wm::WMEvent snap_event(
-        snap_type_ == SNAP_LEFT ?
-        wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
+    const wm::WMEvent snap_event(snap_type_ == SNAP_LEFT
+                                     ? wm::WM_EVENT_SNAP_LEFT
+                                     : wm::WM_EVENT_SNAP_RIGHT);
     window_state->OnWMEvent(&snap_event);
     WmShell::Get()->RecordUserMetricsAction(
-        snap_type_ == SNAP_LEFT ?
-        UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_LEFT :
-        UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_RIGHT);
+        snap_type_ == SNAP_LEFT ? UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_LEFT
+                                : UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_RIGHT);
     SetButtonsToNormalMode(FrameSizeButtonDelegate::ANIMATE_NO);
     return true;
   }
   SetButtonsToNormalMode(FrameSizeButtonDelegate::ANIMATE_YES);
   return false;
 }
 
 void FrameSizeButton::SetButtonsToNormalMode(
     FrameSizeButtonDelegate::Animate animate) {
   in_snap_mode_ = false;
   snap_type_ = SNAP_NONE;
   set_buttons_to_snap_mode_timer_.Stop();
   delegate_->SetButtonsToNormal(animate);
   phantom_window_controller_.reset();
 }
 
 }  // namespace ash