clang-format all of //ash

ash/frame/caption_buttons/frame_caption_button_container_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/frame/caption_buttons/frame_caption_button_container_view.h"
 
 #include <cmath>
 #include <map>
 
 #include "ash/common/ash_switches.h"
@@ skipping 45 matching lines @@
 // Duration of |maximize_mode_animation_| showing.
 // Slide minimize button 500
 // |-------------------------------------------------|
 // Delay 100   Show size button 250
 // |---------|-----------------------|
 const int kShowAnimationDurationMs = kPositionAnimationDurationMs;
 
 // Value of |maximize_mode_animation_| showing to begin animating alpha of
 // |size_button_|.
 float SizeButtonShowStartValue() {
-  return static_cast<float>(kShowAnimationAlphaDelayMs)
-      / kShowAnimationDurationMs;
+  return static_cast<float>(kShowAnimationAlphaDelayMs) /
+         kShowAnimationDurationMs;
 }
 
 // Amount of |maximize_mode_animation_| showing to animate the alpha of
 // |size_button_|.
 float SizeButtonShowDuration() {
-  return static_cast<float>(kAlphaAnimationDurationMs)
-      / kShowAnimationDurationMs;
+  return static_cast<float>(kAlphaAnimationDurationMs) /
+         kShowAnimationDurationMs;
 }
 
 // Amount of |maximize_mode_animation_| hiding to animate the alpha of
 // |size_button_|.
 float SizeButtonHideDuration() {
-  return static_cast<float>(kAlphaAnimationDurationMs)
-      / kHideAnimationDurationMs;
+  return static_cast<float>(kAlphaAnimationDurationMs) /
+         kHideAnimationDurationMs;
 }
 
 // Value of |maximize_mode_animation_| hiding to begin animating the position of
 // |minimize_button_|.
 float HidePositionStartValue() {
-  return 1.0f - static_cast<float>(kHidePositionDelayMs)
-      / kHideAnimationDurationMs;
+  return 1.0f -
+         static_cast<float>(kHidePositionDelayMs) / kHideAnimationDurationMs;
 }
 
 // Converts |point| from |src| to |dst| and hittests against |dst|.
 bool ConvertPointToViewAndHitTest(const views::View* src,
                                   const views::View* dst,
                                   const gfx::Point& point) {
   gfx::Point converted(point);
   views::View::ConvertPointToTarget(src, dst, &converted);
   return dst->HitTestPoint(converted);
 }
@@ skipping 37 matching lines @@
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MAXIMIZE));
   size_button_->SetVisible(size_button_visibility);
   AddChildView(size_button_);
 
   close_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_CLOSE);
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_CLOSE));
   AddChildView(close_button_);
 }
 
-FrameCaptionButtonContainerView::~FrameCaptionButtonContainerView() {
-}
+FrameCaptionButtonContainerView::~FrameCaptionButtonContainerView() {}
 
 void FrameCaptionButtonContainerView::TestApi::EndAnimations() {
   container_view_->maximize_mode_animation_->End();
 }
 
 void FrameCaptionButtonContainerView::SetButtonImage(
     CaptionButtonIcon icon,
     gfx::VectorIconId icon_image_id) {
   button_icon_id_map_[icon] = icon_image_id;
 
-  FrameCaptionButton* buttons[] = {
-    minimize_button_, size_button_, close_button_
-  };
+  FrameCaptionButton* buttons[] = {minimize_button_, size_button_,
+                                   close_button_};
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     if (buttons[i]->icon() == icon)
       buttons[i]->SetImage(icon, FrameCaptionButton::ANIMATE_NO, icon_image_id);
   }
 }
 
 void FrameCaptionButtonContainerView::SetPaintAsActive(bool paint_as_active) {
   minimize_button_->set_paint_as_active(paint_as_active);
   size_button_->set_paint_as_active(paint_as_active);
   close_button_->set_paint_as_active(paint_as_active);
@@ skipping 83 matching lines @@
     PreferredSizeChanged();
   }
 }
 
 void FrameCaptionButtonContainerView::AnimationProgressed(
     const gfx::Animation* animation) {
   double current_value = animation->GetCurrentValue();
   int size_alpha = 0;
   int minimize_x = 0;
   if (maximize_mode_animation_->IsShowing()) {
-    double scaled_value = CapAnimationValue(
-        (current_value - SizeButtonShowStartValue())
-            / SizeButtonShowDuration());
+    double scaled_value =
+        CapAnimationValue((current_value - SizeButtonShowStartValue()) /
+                          SizeButtonShowDuration());
     double tweened_value_alpha =
-        gfx::Tween::CalculateValue(gfx::Tween::EASE_OUT,scaled_value);
+        gfx::Tween::CalculateValue(gfx::Tween::EASE_OUT, scaled_value);
     size_alpha = gfx::Tween::LinearIntValueBetween(tweened_value_alpha, 0, 255);
 
     double tweened_value_slide =
         gfx::Tween::CalculateValue(gfx::Tween::EASE_OUT, current_value);
     minimize_x = gfx::Tween::LinearIntValueBetween(tweened_value_slide,
                                                    size_button_->x(), 0);
   } else {
-    double scaled_value_alpha = CapAnimationValue(
-        (1.0f - current_value) / SizeButtonHideDuration());
+    double scaled_value_alpha =
+        CapAnimationValue((1.0f - current_value) / SizeButtonHideDuration());
     double tweened_value_alpha =
         gfx::Tween::CalculateValue(gfx::Tween::EASE_IN, scaled_value_alpha);
     size_alpha = gfx::Tween::LinearIntValueBetween(tweened_value_alpha, 255, 0);
 
     double scaled_value_position = CapAnimationValue(
-        (HidePositionStartValue() - current_value)
-            / HidePositionStartValue());
+        (HidePositionStartValue() - current_value) / HidePositionStartValue());
     double tweened_value_position =
         gfx::Tween::CalculateValue(gfx::Tween::EASE_OUT, scaled_value_position);
     minimize_x = gfx::Tween::LinearIntValueBetween(tweened_value_position, 0,
                                                    size_button_->x());
   }
   size_button_->SetAlpha(size_alpha);
   minimize_button_->SetX(minimize_x);
 }
 
 void FrameCaptionButtonContainerView::SetButtonIcon(FrameCaptionButton* button,
                                                     CaptionButtonIcon icon,
                                                     Animate animate) {
   // The early return is dependant on |animate| because callers use
   // SetButtonIcon() with ANIMATE_NO to progress |button|'s crossfade animation
   // to the end.
   if (button->icon() == icon &&
       (animate == ANIMATE_YES || !button->IsAnimatingImageSwap())) {
     return;
   }
 
-  FrameCaptionButton::Animate fcb_animate = (animate == ANIMATE_YES) ?
-      FrameCaptionButton::ANIMATE_YES : FrameCaptionButton::ANIMATE_NO;
+  FrameCaptionButton::Animate fcb_animate =
+      (animate == ANIMATE_YES) ? FrameCaptionButton::ANIMATE_YES
+                               : FrameCaptionButton::ANIMATE_NO;
   auto it = button_icon_id_map_.find(icon);
   if (it != button_icon_id_map_.end())
     button->SetImage(icon, fcb_animate, it->second);
 }
 
 bool FrameCaptionButtonContainerView::ShouldSizeButtonBeVisible() const {
-  return !Shell::GetInstance()->maximize_mode_controller()->
-      IsMaximizeModeWindowManagerEnabled() &&
-      frame_->widget_delegate()->CanMaximize();
+  return !Shell::GetInstance()
+              ->maximize_mode_controller()
+              ->IsMaximizeModeWindowManagerEnabled() &&
+         frame_->widget_delegate()->CanMaximize();
 }
 
 void FrameCaptionButtonContainerView::ButtonPressed(views::Button* sender,
                                                     const ui::Event& event) {
   // Abort any animations of the button icons.
   SetButtonsToNormal(ANIMATE_NO);
 
   UserMetricsAction action = UMA_WINDOW_MAXIMIZE_BUTTON_CLICK_MINIMIZE;
   if (sender == minimize_button_) {
     frame_->Minimize();
@@ skipping 21 matching lines @@
   }
   WmShell::Get()->RecordUserMetricsAction(action);
 }
 
 bool FrameCaptionButtonContainerView::IsMinimizeButtonVisible() const {
   return minimize_button_->visible();
 }
 
 void FrameCaptionButtonContainerView::SetButtonsToNormal(Animate animate) {
   SetButtonIcons(CAPTION_BUTTON_ICON_MINIMIZE, CAPTION_BUTTON_ICON_CLOSE,
-      animate);
+                 animate);
   minimize_button_->SetState(views::Button::STATE_NORMAL);
   size_button_->SetState(views::Button::STATE_NORMAL);
   close_button_->SetState(views::Button::STATE_NORMAL);
 }
 
 void FrameCaptionButtonContainerView::SetButtonIcons(
     CaptionButtonIcon minimize_button_icon,
     CaptionButtonIcon close_button_icon,
     Animate animate) {
   SetButtonIcon(minimize_button_, minimize_button_icon, animate);
   SetButtonIcon(close_button_, close_button_icon, animate);
 }
 
 const FrameCaptionButton* FrameCaptionButtonContainerView::GetButtonClosestTo(
     const gfx::Point& position_in_screen) const {
   // Since the buttons all have the same size, the closest button is the button
   // with the center point closest to |position_in_screen|.
   // TODO(pkotwicz): Make the caption buttons not overlap.
   gfx::Point position(position_in_screen);
   views::View::ConvertPointFromScreen(this, &position);
 
-  FrameCaptionButton* buttons[] = {
-    minimize_button_, size_button_, close_button_
-  };
+  FrameCaptionButton* buttons[] = {minimize_button_, size_button_,
+                                   close_button_};
   int min_squared_distance = INT_MAX;
   FrameCaptionButton* closest_button = NULL;
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     FrameCaptionButton* button = buttons[i];
     if (!button->visible())
       continue;
 
     gfx::Point center_point = button->GetLocalBounds().CenterPoint();
     views::View::ConvertPointToTarget(button, this, &center_point);
     int squared_distance = static_cast<int>(
         pow(static_cast<double>(position.x() - center_point.x()), 2) +
         pow(static_cast<double>(position.y() - center_point.y()), 2));
     if (squared_distance < min_squared_distance) {
       min_squared_distance = squared_distance;
       closest_button = button;
     }
   }
   return closest_button;
 }
 
 void FrameCaptionButtonContainerView::SetHoveredAndPressedButtons(
     const FrameCaptionButton* to_hover,
     const FrameCaptionButton* to_press) {
-  FrameCaptionButton* buttons[] = {
-    minimize_button_, size_button_, close_button_
-  };
+  FrameCaptionButton* buttons[] = {minimize_button_, size_button_,
+                                   close_button_};
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     FrameCaptionButton* button = buttons[i];
     views::Button::ButtonState new_state = views::Button::STATE_NORMAL;
     if (button == to_hover)
       new_state = views::Button::STATE_HOVERED;
     else if (button == to_press)
       new_state = views::Button::STATE_PRESSED;
     button->SetState(new_state);
   }
 }
 
 }  // namespace ash