Clean up the tab animations (part 2)

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 <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 399 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, public:
 
 Tab::Tab(TabController* controller)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       favicon_hiding_offset_(0),
       loading_animation_frame_(0),
       should_display_crashed_favicon_(false),
-      throbber_disabled_(false),
       theme_provider_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(hover_controller_(this)),
       showing_icon_(false),
       showing_close_button_(false),
       close_button_color_(0),
       icon_dominant_color_(SK_ColorWHITE) {
   InitTabResources();
 
   // So we get don't get enter/exit on children and don't prematurely stop the
   // hover.
@@ skipping 58 matching lines @@
 #endif
     }
 
   } else if ((data_.capture_state == TabRendererData::CAPTURE_STATE_NONE) &&
              (old.capture_state != TabRendererData::CAPTURE_STATE_NONE)) {
     StopRecordingAnimation();
 
   } else if ((data_.capture_state != TabRendererData::CAPTURE_STATE_NONE) &&
              (old.capture_state == TabRendererData::CAPTURE_STATE_NONE)) {
     StartRecordingAnimation();
+

[sky, 2013/01/23 16:10:02]

nuke this, in fact nuke 494 and 490 as well.

   } else {
     if (IsPerformingCrashAnimation())
       StopCrashAnimation();
     ResetCrashedFavicon();
   }
 
   // If the favicon changed, re-compute its dominant color.
   if (controller() &&
       controller()->IsImmersiveStyle() &&
       !data_.favicon.isNull() &&
       !data_.favicon.BackedBySameObjectAs(old.favicon))
     UpdateIconDominantColor();
 
   DataChanged(old);
 
   Layout();
   SchedulePaint();
 }
 
 void Tab::UpdateLoadingAnimation(TabRendererData::NetworkState state) {
-  // If this is an extension app and a command line flag is set,
-  // then disable the throbber.
-  throbber_disabled_ = data().app &&
-      CommandLine::ForCurrentProcess()->HasSwitch(switches::kAppsNoThrob);
-
-  if (throbber_disabled_)
-    return;
-
   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;
   }
 
   TabRendererData::NetworkState old_state = data_.network_state;
   data_.network_state = state;
   AdvanceLoadingAnimation(old_state, state);
 }
 
 void Tab::StartPulse() {
-  if (!tab_animation_.get()) {
-    tab_animation_.reset(new ui::ThrobAnimation(this));
-    tab_animation_->SetSlideDuration(kPulseDurationMs);
-    if (animation_container_.get())
-      tab_animation_->SetContainer(animation_container_.get());
-  }
-  tab_animation_->Reset();
-  tab_animation_->StartThrobbing(std::numeric_limits<int>::max());
+  ui::ThrobAnimation* animation = new ui::ThrobAnimation(this);
+  animation->SetSlideDuration(kPulseDurationMs);
+  if (animation_container_.get())
+    animation->SetContainer(animation_container_.get());
+  animation->StartThrobbing(std::numeric_limits<int>::max());
+  tab_animation_.reset(animation);
 }
 
 void Tab::StopPulse() {
   if (!tab_animation_.get())
     return;
-
-  tab_animation_->Stop();  // Do stop so we get notified.
+  tab_animation_->Stop();
   tab_animation_.reset(NULL);
 }
 
 void Tab::StartMiniTabTitleAnimation() {
-  if (!mini_title_animation_.get()) {
+  // We can only do this animation if the tab is mini because we will
+  // upcast tab_animation back to MultiAnimation when we draw.
+  if (!data().mini)
+    return;
+  if (!tab_animation_.get()) {
     ui::MultiAnimation::Parts parts;
     parts.push_back(
         ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration1MS,
                                  ui::Tween::EASE_OUT));
     parts.push_back(
         ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration2MS,
                                  ui::Tween::ZERO));
     parts.push_back(
         ui::MultiAnimation::Part(kMiniTitleChangeAnimationDuration3MS,
                                  ui::Tween::EASE_IN));
     parts[0].start_time_ms = kMiniTitleChangeAnimationStart1MS;
     parts[0].end_time_ms = kMiniTitleChangeAnimationEnd1MS;
     parts[2].start_time_ms = kMiniTitleChangeAnimationStart3MS;
     parts[2].end_time_ms = kMiniTitleChangeAnimationEnd3MS;
-    mini_title_animation_.reset(new ui::MultiAnimation(
-        parts,
-        base::TimeDelta::FromMilliseconds(
-            kMiniTitleChangeAnimationIntervalMS)));
-    mini_title_animation_->SetContainer(animation_container());
-    mini_title_animation_->set_delegate(this);
+    base::TimeDelta timeout =
+        base::TimeDelta::FromMilliseconds(kMiniTitleChangeAnimationIntervalMS);
+    ui::MultiAnimation* animation = new ui::MultiAnimation(parts, timeout);
+    if (animation_container_.get())
+      animation->SetContainer(animation_container_.get());
+    animation->set_delegate(this);
+    tab_animation_.reset(animation);
   }
-  mini_title_animation_->Start();
+  tab_animation_->Start();
 }
 
 void Tab::StopMiniTabTitleAnimation() {
-  if (mini_title_animation_.get())
-    mini_title_animation_->Stop();
+  if (!tab_animation_.get())
+    return;
+  tab_animation_->Stop();
+  tab_animation_.reset(NULL);
 }
 
 void Tab::UpdateIconDominantColor() {
   icon_dominant_color_ =
       color_utils::CalculateKMeanColorOfBitmap(*data_.favicon.bitmap());
 }
 
 // static
 gfx::Size Tab::GetBasicMinimumUnselectedSize() {
   InitTabResources();
@@ skipping 472 matching lines @@
       IsActive() ? kImmersiveActiveTabColor : kImmersiveInactiveTabColor;
   gfx::Rect main_bar_rect(
       main_bar_left, 0, main_bar_right - main_bar_left, kImmersiveBarHeight);
   canvas->FillRect(main_bar_rect, color);
 }
 
 void Tab::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsActive()) {
     PaintActiveTabBackground(canvas);
   } else {
-    if (mini_title_animation_.get() && mini_title_animation_->is_animating())
-      PaintInactiveTabBackgroundWithTitleChange(canvas);
-    else
+    if (tab_animation_.get() &&
+        tab_animation_->is_animating() &&
+        data().mini) {

[sky, 2013/01/23 16:10:02]

What happens if we start animating while not mini, then change to mini?

[cpu_(ooo_6.6-7.5), 2013/01/23 18:31:40]

Visually, nothing bad. The behavior is though a bit different:

Currently, if the minitab is animating and we unpin, the animation continues on
the regular tab, which imho its a bug, with this patch the animation stops.

Not just because of that data().mini check but also because at unpin we call
TabStrip::StopAllHighlighting() which calls Tab::StopPulse() which deletes the
animation.

I am guessing in the existing code the mini_title_animation does not get
canceled. Now, to be fair that might have been something I introduced in the
last cleanup or might have been there, no idea.

You can test with
alienrancher.appspot.com/html/title_change.html

[sky, 2013/01/23 19:33:02]

Doesn't this mean you could do the wrong cast though?

[cpu_(ooo_6.6-7.5), 2013/01/23 20:35:07]

Ah, I see what you mean. I have the check of line 550. Let me know if that is
enough.

[sky, 2013/01/23 21:07:22]

What happens if we StartPulse() and the tab is mini, or not-mini then becomes
mini? Seems like we should force the animation to stop when changing mini state.

+      ui::MultiAnimation* animation =
+          static_cast<ui::MultiAnimation*>(tab_animation_.get());
+      PaintInactiveTabBackgroundWithTitleChange(canvas, animation);
+    } else {
       PaintInactiveTabBackground(canvas);
+    }
 
     double throb_value = GetThrobValue();
     if (throb_value > 0) {
       canvas->SaveLayerAlpha(static_cast<int>(throb_value * 0xff),
                              GetLocalBounds());
       PaintActiveTabBackground(canvas);
       canvas->Restore();
     }
   }
 }
 
-void Tab::PaintInactiveTabBackgroundWithTitleChange(gfx::Canvas* canvas) {
+void Tab::PaintInactiveTabBackgroundWithTitleChange(
+    gfx::Canvas* canvas, ui::MultiAnimation* animation) {
   // Render the inactive tab background. We'll use this for clipping.
   gfx::Canvas background_canvas(size(), canvas->scale_factor(), false);
   PaintInactiveTabBackground(&background_canvas);
 
   gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
 
   // Draw a radial gradient to hover_canvas.
   gfx::Canvas hover_canvas(size(), canvas->scale_factor(), false);
   int radius = kMiniTitleChangeGradientRadius;
   int x0 = width() + radius - kMiniTitleChangeInitialXOffset;
   int x1 = radius;
   int x2 = -radius;
   int x;
-  if (mini_title_animation_->current_part_index() == 0) {
-    x = mini_title_animation_->CurrentValueBetween(x0, x1);
-  } else if (mini_title_animation_->current_part_index() == 1) {
+  if (animation->current_part_index() == 0) {
+    x = animation->CurrentValueBetween(x0, x1);
+  } else if (animation->current_part_index() == 1) {
     x = x1;
   } else {
-    x = mini_title_animation_->CurrentValueBetween(x1, x2);
+    x = animation->CurrentValueBetween(x1, x2);
   }
   SkPoint center_point;
   center_point.iset(x, 0);
   SkColor colors[2] = { kMiniTitleChangeGradientColor1,
                         kMiniTitleChangeGradientColor2 };
   skia::RefPtr<SkShader> shader = skia::AdoptRef(
       SkGradientShader::CreateRadial(
           center_point, SkIntToScalar(radius), colors, NULL, 2,
           SkShader::kClamp_TileMode));
   SkPaint paint;
   paint.setShader(shader.get());
   hover_canvas.DrawRect(gfx::Rect(x - radius, -radius, radius * 2, radius * 2),
                         paint);
 
   // Draw the radial gradient clipped to the background into hover_image.
   gfx::ImageSkia hover_image = gfx::ImageSkiaOperations::CreateMaskedImage(
       gfx::ImageSkia(hover_canvas.ExtractImageRep()), background_image);
 
   // Draw the tab background to the canvas.
   canvas->DrawImageInt(background_image, 0, 0);
 
   // And then the gradient on top of that.
-  if (mini_title_animation_->current_part_index() == 2) {
-    uint8 alpha = mini_title_animation_->CurrentValueBetween(255, 0);
+  if (animation->current_part_index() == 2) {
+    uint8 alpha = animation->CurrentValueBetween(255, 0);
     canvas->DrawImageInt(hover_image, 0, 0, alpha);
   } else {
     canvas->DrawImageInt(hover_image, 0, 0);
   }
 }
 
 void Tab::PaintInactiveTabBackground(gfx::Canvas* canvas) {
   int tab_id;
   if (GetWidget() && GetWidget()->GetTopLevelWidget()->ShouldUseNativeFrame()) {
     tab_id = IDR_THEME_TAB_BACKGROUND_V;
@@ skipping 341 matching lines @@
 bool Tab::ShouldShowCloseBox() const {
   // The active tab never clips close button.
   return !data().mini && (IsActive() || IconCapacity() >= 3);
 }
 
 double Tab::GetThrobValue() {
   bool is_selected = IsSelected();
   double min = is_selected ? kSelectedTabOpacity : 0;
   double scale = is_selected ? kSelectedTabThrobScale : 1;
 
-  if (tab_animation_.get() && tab_animation_->is_animating())
-    return tab_animation_->GetCurrentValue() * kHoverOpacity * scale + min;
+  if (!data().mini) {
+    if (tab_animation_.get() && tab_animation_->is_animating())
+      return tab_animation_->GetCurrentValue() * kHoverOpacity * scale + min;
+  }
 
   if (hover_controller_.ShouldDraw()) {
     return kHoverOpacity * hover_controller_.GetAnimationValue() * scale +
         min;
   }
 
   return is_selected ? kSelectedTabOpacity : 0;
 }
 
 void Tab::SetFaviconHidingOffset(int offset) {
@@ skipping 114 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }