Rename MaximizeMode to TabletMode

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/frame/caption_buttons/frame_caption_button.h"
 #include "ash/frame/caption_buttons/frame_size_button.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
-#include "ash/wm/maximize_mode/maximize_mode_controller.h"
+#include "ash/wm/tablet_mode/tablet_mode_controller.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/vector_icon_types.h"
 #include "ui/strings/grit/ui_strings.h"  // Accessibility names
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 
 namespace {
 
 // Duration of the animation of the position of |minimize_button_|.
 const int kPositionAnimationDurationMs = 500;
 
 // Duration of the animation of the alpha of |size_button_|.
 const int kAlphaAnimationDurationMs = 250;
 
-// Delay during |maximize_mode_animation_| hide to wait before beginning to
+// Delay during |tablet_mode_animation_| hide to wait before beginning to
 // animate the position of |minimize_button_|.
 const int kHidePositionDelayMs = 100;
 
-// Duration of |maximize_mode_animation_| hiding.
+// Duration of |tablet_mode_animation_| hiding.
 // Hiding size button 250
 // |------------------------|
 // Delay 100      Slide minimize button 500
 // |---------|-------------------------------------------------|
 const int kHideAnimationDurationMs =
     kHidePositionDelayMs + kPositionAnimationDurationMs;
 
-// Delay during |maximize_mode_animation_| show to wait before beginning to
+// Delay during |tablet_mode_animation_| show to wait before beginning to
 // animate the alpha of |size_button_|.
 const int kShowAnimationAlphaDelayMs = 100;
 
-// Duration of |maximize_mode_animation_| showing.
+// Duration of |tablet_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
+// Value of |tablet_mode_animation_| showing to begin animating alpha of
 // |size_button_|.
 float SizeButtonShowStartValue() {
   return static_cast<float>(kShowAnimationAlphaDelayMs) /
          kShowAnimationDurationMs;
 }
 
-// Amount of |maximize_mode_animation_| showing to animate the alpha of
+// Amount of |tablet_mode_animation_| showing to animate the alpha of
 // |size_button_|.
 float SizeButtonShowDuration() {
   return static_cast<float>(kAlphaAnimationDurationMs) /
          kShowAnimationDurationMs;
 }
 
-// Amount of |maximize_mode_animation_| hiding to animate the alpha of
+// Amount of |tablet_mode_animation_| hiding to animate the alpha of
 // |size_button_|.
 float SizeButtonHideDuration() {
   return static_cast<float>(kAlphaAnimationDurationMs) /
          kHideAnimationDurationMs;
 }
 
-// Value of |maximize_mode_animation_| hiding to begin animating the position of
+// Value of |tablet_mode_animation_| hiding to begin animating the position of
 // |minimize_button_|.
 float HidePositionStartValue() {
   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) {
@@ skipping 15 matching lines @@
 const char FrameCaptionButtonContainerView::kViewClassName[] =
     "FrameCaptionButtonContainerView";
 
 FrameCaptionButtonContainerView::FrameCaptionButtonContainerView(
     views::Widget* frame)
     : frame_(frame),
       minimize_button_(NULL),
       size_button_(NULL),
       close_button_(NULL) {
   bool size_button_visibility = ShouldSizeButtonBeVisible();
-  maximize_mode_animation_.reset(new gfx::SlideAnimation(this));
-  maximize_mode_animation_->SetTweenType(gfx::Tween::LINEAR);
+  tablet_mode_animation_.reset(new gfx::SlideAnimation(this));
+  tablet_mode_animation_->SetTweenType(gfx::Tween::LINEAR);
 
   // Ensure animation tracks visibility of size button.
   if (size_button_visibility)
-    maximize_mode_animation_->Reset(1.0f);
+    tablet_mode_animation_->Reset(1.0f);
 
   // Insert the buttons left to right.
   minimize_button_ = new FrameCaptionButton(this, CAPTION_BUTTON_ICON_MINIMIZE);
   minimize_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_APP_ACCNAME_MINIMIZE));
   minimize_button_->SetVisible(frame_->widget_delegate()->CanMinimize());
   AddChildView(minimize_button_);
 
   size_button_ = new FrameSizeButton(this, frame, this);
   size_button_->SetAccessibleName(
       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() {}
 
 void FrameCaptionButtonContainerView::TestApi::EndAnimations() {
-  container_view_->maximize_mode_animation_->End();
+  container_view_->tablet_mode_animation_->End();
 }
 
 void FrameCaptionButtonContainerView::SetButtonImage(
     CaptionButtonIcon icon,
     const gfx::VectorIcon& icon_definition) {
   button_icon_map_[icon] = &icon_definition;
 
   FrameCaptionButton* buttons[] = {minimize_button_, size_button_,
                                    close_button_};
   for (size_t i = 0; i < arraysize(buttons); ++i) {
@@ skipping 31 matching lines @@
              ConvertPointToViewAndHitTest(this, minimize_button_, point)) {
     return HTMINBUTTON;
   }
   return HTNOWHERE;
 }
 
 void FrameCaptionButtonContainerView::UpdateSizeButtonVisibility() {
   bool visible = ShouldSizeButtonBeVisible();
   if (visible) {
     size_button_->SetVisible(true);
-    maximize_mode_animation_->SetSlideDuration(kShowAnimationDurationMs);
-    maximize_mode_animation_->Show();
+    tablet_mode_animation_->SetSlideDuration(kShowAnimationDurationMs);
+    tablet_mode_animation_->Show();
   } else {
-    maximize_mode_animation_->SetSlideDuration(kHideAnimationDurationMs);
-    maximize_mode_animation_->Hide();
+    tablet_mode_animation_->SetSlideDuration(kHideAnimationDurationMs);
+    tablet_mode_animation_->Hide();
   }
 }
 
 void FrameCaptionButtonContainerView::SetButtonSize(const gfx::Size& size) {
   minimize_button_->set_preferred_size(size);
   size_button_->set_preferred_size(size);
   close_button_->set_preferred_size(size);
 }
 
 gfx::Size FrameCaptionButtonContainerView::CalculatePreferredSize() const {
@@ skipping 10 matching lines @@
   int x = 0;
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
       continue;
 
     gfx::Size size = child->GetPreferredSize();
     child->SetBounds(x, 0, size.width(), size.height());
     x += size.width();
   }
-  if (maximize_mode_animation_->is_animating()) {
-    AnimationProgressed(maximize_mode_animation_.get());
+  if (tablet_mode_animation_->is_animating()) {
+    AnimationProgressed(tablet_mode_animation_.get());
   }
 }
 
 const char* FrameCaptionButtonContainerView::GetClassName() const {
   return kViewClassName;
 }
 
 void FrameCaptionButtonContainerView::AnimationEnded(
     const gfx::Animation* animation) {
   // Ensure that position is calculated at least once.
   AnimationProgressed(animation);
 
-  double current_value = maximize_mode_animation_->GetCurrentValue();
+  double current_value = tablet_mode_animation_->GetCurrentValue();
   if (current_value == 0.0) {
     size_button_->SetVisible(false);
     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()) {
+  if (tablet_mode_animation_->IsShowing()) {
     double scaled_value =
         CapAnimationValue((current_value - SizeButtonShowStartValue()) /
                           SizeButtonShowDuration());
     double tweened_value_alpha =
         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,
@@ skipping 30 matching lines @@
   FrameCaptionButton::Animate fcb_animate =
       (animate == ANIMATE_YES) ? FrameCaptionButton::ANIMATE_YES
                                : FrameCaptionButton::ANIMATE_NO;
   auto it = button_icon_map_.find(icon);
   if (it != button_icon_map_.end())
     button->SetImage(icon, fcb_animate, *it->second);
 }
 
 bool FrameCaptionButtonContainerView::ShouldSizeButtonBeVisible() const {
   return !Shell::Get()
-              ->maximize_mode_controller()
-              ->IsMaximizeModeWindowManagerEnabled() &&
+              ->tablet_mode_controller()
+              ->IsTabletModeWindowManagerEnabled() &&
          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_) {
@@ skipping 81 matching lines @@
     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