Misc. Tab-related cleanup.

chrome/browser/ui/views/tabs/tab.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 "chrome/browser/ui/views/tabs/tab.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 50 matching lines @@
 #include "ui/views/window/non_client_view.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/env.h"
 #endif
 
 using base::UserMetricsAction;
 
 namespace {
 
-// How long the pulse throb takes.
-const int kPulseDurationMs = 200;
-
 // Width of touch tabs.
 const int kTouchWidth = 120;
 
 const int kExtraLeftPaddingToBalanceCloseButtonPadding = 2;
 const int kAfterTitleSpacing = 4;
 
 // When a non-pinned tab becomes a pinned tab the width of the tab animates. If
 // the width of a pinned tab is at least kPinnedTabExtraWidthToRenderAsNormal
 // larger than the desired pinned tab width then the tab is rendered as a normal
 // tab. This is done to avoid having the title immediately disappear when
 // transitioning a tab from normal to pinned tab.
 const int kPinnedTabExtraWidthToRenderAsNormal = 30;
 
 // How opaque to make the hover state (out of 1).
 const double kHoverOpacity = 0.33;
 
 // Opacity of the active tab background painted over inactive selected tabs.
 const double kSelectedTabOpacity = 0.3;
 
 // Inactive selected tabs have their throb value scaled by this.
 const double kSelectedTabThrobScale = 0.95 - kSelectedTabOpacity;
 
-// Durations for the various parts of the pinned tab title animation.
-const int kPinnedTitleChangeAnimationDuration1MS = 1600;
-const int kPinnedTitleChangeAnimationStart1MS = 0;
-const int kPinnedTitleChangeAnimationEnd1MS = 1900;
-const int kPinnedTitleChangeAnimationDuration2MS = 0;
-const int kPinnedTitleChangeAnimationDuration3MS = 550;
-const int kPinnedTitleChangeAnimationStart3MS = 150;
-const int kPinnedTitleChangeAnimationEnd3MS = 800;
-const int kPinnedTitleChangeAnimationIntervalMS = 40;
-
 // Offset from the right edge for the start of the pinned title change
 // animation.
 const int kPinnedTitleChangeInitialXOffset = 6;
 
 // Max number of images to cache. This has to be at least two since rounding
 // errors may lead to tabs in the same tabstrip having different sizes.
 const size_t kMaxImageCacheSize = 4;
 
 // Height of the miniature tab strip in immersive mode.
 const int kImmersiveTabHeight = 3;
@@ skipping 19 matching lines @@
 
 // Returns the width of the tab endcap at scale 1.  More precisely, this is the
 // width of the curve making up either the outer or inner edge of the stroke;
 // since these two curves are horizontally offset by 1 px (regardless of scale),
 // the total width of the endcap from tab outer edge to the inside end of the
 // stroke inner edge is (GetUnscaledEndcapWidth() * scale) + 1.
 float GetUnscaledEndcapWidth() {
   return GetLayoutInsets(TAB).left() - 0.5f;
 }
 
-// Stop()s |animation| and then deletes it. We do this rather than just deleting
-// so that the delegate is notified before the destruction.
-void StopAndDeleteAnimation(scoped_ptr<gfx::Animation> animation) {
-  if (animation)
-    animation->Stop();
-}
-
 void DrawHighlight(gfx::Canvas* canvas,
                    const SkPoint& p,
                    SkScalar radius,
                    SkAlpha alpha) {
   const SkColor colors[2] = { SkColorSetA(SK_ColorWHITE, alpha),
                               SkColorSetA(SK_ColorWHITE, 0) };
   skia::RefPtr<SkShader> shader = skia::AdoptRef(SkGradientShader::CreateRadial(
       p, radius, colors, nullptr, 2, SkShader::kClamp_TileMode));
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
@@ skipping 335 matching lines @@
 // static
 const char Tab::kViewClassName[] = "Tab";
 Tab::TabImages Tab::active_images_ = {0};
 Tab::TabImages Tab::inactive_images_ = {0};
 Tab::TabImages Tab::mask_images_ = {0};
 Tab::ImageCache* Tab::image_cache_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, public:
 
-Tab::Tab(TabController* controller)
+Tab::Tab(TabController* controller, gfx::AnimationContainer* container)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       detached_(false),
       favicon_hiding_offset_(0),
       immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
+      pulse_animation_(new gfx::ThrobAnimation(this)),
+      crash_icon_animation_(new FaviconCrashAnimation(this)),
+      animation_container_(container),
       throbber_(nullptr),
       media_indicator_button_(nullptr),
       close_button_(nullptr),
       title_(new views::Label()),
       tab_activated_with_last_tap_down_(false),
       hover_controller_(this),
       showing_icon_(false),
       showing_media_indicator_(false),
       showing_close_button_(false),
       button_color_(SK_ColorTRANSPARENT) {
@@ skipping 39 matching lines @@
       SkColorSetRGB(0xA8, 0x35, 0x2A));
   close_button_->SetImage(views::CustomButton::STATE_HOVERED, &hovered);
   close_button_->SetImage(views::CustomButton::STATE_PRESSED, &pressed);
 
   // Disable animation so that the red danger sign shows up immediately
   // to help avoid mis-clicks.
   close_button_->SetAnimationDuration(0);
   AddChildView(close_button_);
 
   set_context_menu_controller(this);
+
+  const int kPulseDurationMs = 200;
+  pulse_animation_->SetSlideDuration(kPulseDurationMs);
+  pulse_animation_->SetContainer(animation_container_.get());
+
+  const int kPinnedTitleChangeAnimationDuration1MS = 1600;
+  const int kPinnedTitleChangeAnimationStart1MS = 0;
+  const int kPinnedTitleChangeAnimationEnd1MS = 1900;
+  const int kPinnedTitleChangeAnimationDuration2MS = 0;
+  const int kPinnedTitleChangeAnimationDuration3MS = 550;
+  const int kPinnedTitleChangeAnimationStart3MS = 150;
+  const int kPinnedTitleChangeAnimationEnd3MS = 800;
+  const int kPinnedTitleChangeAnimationIntervalMS = 40;
+  gfx::MultiAnimation::Parts parts;
+  parts.push_back(gfx::MultiAnimation::Part(
+      kPinnedTitleChangeAnimationDuration1MS,
+      kPinnedTitleChangeAnimationStart1MS,
+      kPinnedTitleChangeAnimationEnd1MS,
+      gfx::Tween::EASE_OUT));
+  parts.push_back(gfx::MultiAnimation::Part(
+      kPinnedTitleChangeAnimationDuration2MS,
+      gfx::Tween::ZERO));
+  parts.push_back(gfx::MultiAnimation::Part(
+      kPinnedTitleChangeAnimationDuration3MS,
+      kPinnedTitleChangeAnimationStart3MS,
+      kPinnedTitleChangeAnimationEnd3MS,
+      gfx::Tween::EASE_IN));
+  const base::TimeDelta timeout =
+      base::TimeDelta::FromMilliseconds(kPinnedTitleChangeAnimationIntervalMS);
+  pinned_title_change_animation_.reset(new gfx::MultiAnimation(parts, timeout));
+  pinned_title_change_animation_->SetContainer(animation_container_.get());
+  pinned_title_change_animation_->set_delegate(this);
+
+  hover_controller_.SetAnimationContainer(animation_container_.get());
 }
 
 Tab::~Tab() {
 }
 
-void Tab::SetAnimationContainer(gfx::AnimationContainer* container) {
-  animation_container_ = container;
-  hover_controller_.SetAnimationContainer(container);
-}
-
 bool Tab::IsActive() const {
   return controller_->IsActiveTab(this);
 }
 
 void Tab::ActiveStateChanged() {
   OnButtonColorMaybeChanged();
   media_indicator_button_->UpdateEnabledForMuteToggle();
   Layout();
 }
 
@@ skipping 18 matching lines @@
   base::string16 title = data_.title;
   if (title.empty()) {
     title = data_.loading ?
         l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) :
         CoreTabHelper::GetDefaultTitle();
   } else {
     Browser::FormatTitleForDisplay(&title);
   }
   title_->SetText(title);
 
-  if (data_.IsCrashed()) {
-    if (!should_display_crashed_favicon_ && !crash_icon_animation_) {
-      data_.media_state = TAB_MEDIA_STATE_NONE;
-      crash_icon_animation_.reset(new FaviconCrashAnimation(this));
-      crash_icon_animation_->Start();
-    }
-  } else {
-    if (crash_icon_animation_)
-        crash_icon_animation_.reset();
+  if (!data_.IsCrashed()) {
+    crash_icon_animation_->Stop();
     should_display_crashed_favicon_ = false;
     favicon_hiding_offset_ = 0;
+  } else if (!should_display_crashed_favicon_ &&
+             !crash_icon_animation_->is_animating()) {
+    data_.media_state = TAB_MEDIA_STATE_NONE;
+    crash_icon_animation_->Start();
   }
 
   if (data_.media_state != old.media_state)
     media_indicator_button_->TransitionToMediaState(data_.media_state);
 
   if (old.pinned != data_.pinned)
     StopPinnedTabTitleAnimation();
 
   DataChanged(old);
 
   Layout();
   SchedulePaint();
 }
 
 void Tab::UpdateLoadingAnimation(TabRendererData::NetworkState state) {
   if (state == data_.network_state &&
       state == TabRendererData::NETWORK_STATE_NONE) {
     // If the network state is none and hasn't changed, do nothing. Otherwise we
     // need to advance the animation frame.
     return;
   }
 
   data_.network_state = state;
   AdvanceLoadingAnimation();
 }
 
 void Tab::StartPulse() {
-  pulse_animation_.reset(new gfx::ThrobAnimation(this));
-  pulse_animation_->SetSlideDuration(kPulseDurationMs);
-  if (animation_container_.get())
-    pulse_animation_->SetContainer(animation_container_.get());
   pulse_animation_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 void Tab::StopPulse() {
-  StopAndDeleteAnimation(std::move(pulse_animation_));
+  pulse_animation_->Stop();
 }
 
 void Tab::StartPinnedTabTitleAnimation() {
-  if (!data().pinned)
-    return;
-  if (!pinned_title_change_animation_) {
-    gfx::MultiAnimation::Parts parts;
-    parts.push_back(
-        gfx::MultiAnimation::Part(kPinnedTitleChangeAnimationDuration1MS,
-                                 gfx::Tween::EASE_OUT));
-    parts.push_back(
-        gfx::MultiAnimation::Part(kPinnedTitleChangeAnimationDuration2MS,
-                                 gfx::Tween::ZERO));
-    parts.push_back(
-        gfx::MultiAnimation::Part(kPinnedTitleChangeAnimationDuration3MS,
-                                 gfx::Tween::EASE_IN));
-    parts[0].start_time_ms = kPinnedTitleChangeAnimationStart1MS;
-    parts[0].end_time_ms = kPinnedTitleChangeAnimationEnd1MS;
-    parts[2].start_time_ms = kPinnedTitleChangeAnimationStart3MS;
-    parts[2].end_time_ms = kPinnedTitleChangeAnimationEnd3MS;
-    base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(
-        kPinnedTitleChangeAnimationIntervalMS);
-    pinned_title_change_animation_.reset(
-        new gfx::MultiAnimation(parts, timeout));
-    if (animation_container_.get())
-      pinned_title_change_animation_->SetContainer(animation_container_.get());
-    pinned_title_change_animation_->set_delegate(this);
-  }
-  pinned_title_change_animation_->Start();
+  if (data().pinned)
+    pinned_title_change_animation_->Start();
 }
 
 void Tab::StopPinnedTabTitleAnimation() {
-  StopAndDeleteAnimation(std::move(pinned_title_change_animation_));
+  pinned_title_change_animation_->Stop();
 }
 
 int Tab::GetWidthOfLargestSelectableRegion() const {
   // Assume the entire region to the left of the media indicator and/or close
   // buttons is available for click-to-select.  If neither are visible, the
   // entire tab region is available.
   const int indicator_left = showing_media_indicator_ ?
       media_indicator_button_->x() : width();
   const int close_button_left = showing_close_button_ ?
       close_button_->x() : width();
@@ skipping 61 matching lines @@
   return (GetUnscaledEndcapWidth() - 4) /
       (GetMinimumInactiveSize().height() - 4);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, AnimationDelegate overrides:
 
 void Tab::AnimationProgressed(const gfx::Animation* animation) {
   // Ignore if the pulse animation is being performed on active tab because
   // it repaints the same image. See |Tab::PaintTabBackground()|.
-  if (animation == pulse_animation_.get() && IsActive())
-    return;
-  SchedulePaint();
+  if ((animation != pulse_animation_.get()) || !IsActive())
+    SchedulePaint();
 }
 
 void Tab::AnimationCanceled(const gfx::Animation* animation) {
   SchedulePaint();
 }
 
 void Tab::AnimationEnded(const gfx::Animation* animation) {
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::ButtonListener overrides:
 
 void Tab::ButtonPressed(views::Button* sender, const ui::Event& event) {
-  if (media_indicator_button_ && media_indicator_button_->visible()) {
-    if (media_indicator_button_->enabled())
-      content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
-    else if (data_.media_state == TAB_MEDIA_STATE_AUDIO_PLAYING)
-      content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
-    else
-      content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
-  } else {
+  if (!media_indicator_button_ || !media_indicator_button_->visible())
     content::RecordAction(UserMetricsAction("CloseTab_NoMediaIndicator"));
-  }
+  else if (media_indicator_button_->enabled())
+    content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
+  else if (data_.media_state == TAB_MEDIA_STATE_AUDIO_PLAYING)
+    content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
+  else
+    content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
 
   const CloseTabSource source =
       (event.type() == ui::ET_MOUSE_RELEASED &&
-       (event.flags() & ui::EF_FROM_TOUCH) == 0) ? CLOSE_TAB_FROM_MOUSE :
-      CLOSE_TAB_FROM_TOUCH;
+       !(event.flags() & ui::EF_FROM_TOUCH)) ? CLOSE_TAB_FROM_MOUSE
+                                             : CLOSE_TAB_FROM_TOUCH;
   DCHECK_EQ(close_button_, sender);
   controller_->CloseTab(this, source);
   if (event.type() == ui::ET_GESTURE_TAP)
     TouchUMA::RecordGestureAction(TouchUMA::GESTURE_TABCLOSE_TAP);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::ContextMenuController overrides:
 
 void Tab::ShowContextMenuForView(views::View* source,
@@ skipping 398 matching lines @@
 void Tab::PaintTab(gfx::Canvas* canvas) {
   PaintTabBackground(canvas);
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
 void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
   // Use transparency for the draw-attention animation.
   int alpha = 255;
-  if (pulse_animation_ && pulse_animation_->is_animating() && !data().pinned) {
+  if (pulse_animation_->is_animating() && !data().pinned) {
     alpha = pulse_animation_->CurrentValueBetween(
-        255, static_cast<int>(255 * kImmersiveTabMinThrobOpacity));
+        255, gfx::ToRoundedInt(255 * kImmersiveTabMinThrobOpacity));
   }
 
   // Draw a gray rectangle to represent the tab. This works for pinned tabs as
   // well as regular ones. The active tab has a brigher bar.
   SkColor color =
       IsActive() ? kImmersiveActiveTabColor : kImmersiveInactiveTabColor;
   gfx::Rect bar_rect = GetImmersiveBarRect();
   canvas->FillRect(bar_rect, SkColorSetA(color, alpha));
 
   // Paint network activity indicator.
@@ skipping 27 matching lines @@
 
 void Tab::PaintTabBackground(gfx::Canvas* canvas) {
   const int kActiveTabFillId = IDR_THEME_TOOLBAR;
   const bool has_custom_image =
       GetThemeProvider()->HasCustomImage(kActiveTabFillId);
   const int y_offset = -GetYInsetForActiveTabBackground();
   if (IsActive()) {
     PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
                                   has_custom_image, y_offset);
   } else {
-    if (pinned_title_change_animation_ &&
-        pinned_title_change_animation_->is_animating())
+    if (pinned_title_change_animation_->is_animating())
       PaintInactiveTabBackgroundWithTitleChange(canvas);
     else
       PaintInactiveTabBackground(canvas);
 
     const double throb_value = GetThrobValue();
     if (throb_value > 0) {
       canvas->SaveLayerAlpha(gfx::ToRoundedInt(throb_value * 0xff),
                              GetLocalBounds());
       PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
                                     has_custom_image, y_offset);
@@ skipping 324 matching lines @@
 }
 
 double Tab::GetThrobValue() {
   const bool is_selected = IsSelected();
   double val = is_selected ? kSelectedTabOpacity : 0;
   const double offset =
       is_selected ? (kSelectedTabThrobScale * kHoverOpacity) : kHoverOpacity;
 
   // Showing both the pulse and title change animation at the same time is too
   // much.
-  if (pulse_animation_ && pulse_animation_->is_animating() &&
-      (!pinned_title_change_animation_ ||
-       !pinned_title_change_animation_->is_animating())) {
+  if (pulse_animation_->is_animating() &&
+      !pinned_title_change_animation_->is_animating()) {
     val += pulse_animation_->GetCurrentValue() * offset;
   } else if (hover_controller_.ShouldDraw()) {
     val += hover_controller_.GetAnimationValue() * offset;
   }
   return val;
 }
 
 void Tab::SetFaviconHidingOffset(int offset) {
   favicon_hiding_offset_ = offset;
   ScheduleIconPaint();
@@ skipping 21 matching lines @@
                             &close_button_normal_image);
   }
 }
 
 void Tab::ScheduleIconPaint() {
   gfx::Rect bounds = favicon_bounds_;
   if (bounds.IsEmpty())
     return;
 
   // Extends the area to the bottom when the crash animation is in progress.
-  if (crash_icon_animation_)
+  if (crash_icon_animation_->is_animating())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
 void Tab::GetFillPath(float scale, SkPath* fill) const {
   const float right = width() * scale;
   const float bottom = height() * scale;
   const float unscaled_endcap_width = GetUnscaledEndcapWidth();
 
@@ skipping 96 matching lines @@
   inactive_images_.image_c = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_CENTER);
   inactive_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_RIGHT);
   inactive_images_.l_width = inactive_images_.image_l->width();
   inactive_images_.r_width = inactive_images_.image_r->width();
 
   mask_images_.image_l = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_LEFT);
   mask_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_RIGHT);
   mask_images_.l_width = mask_images_.image_l->width();
   mask_images_.r_width = mask_images_.image_r->width();
 }