Fix possible bad cast in Tab

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 167 matching lines @@
                      icon_height, filter, paint);
 }
 
 chrome::HostDesktopType GetHostDesktopType(views::View* view) {
   // Widget is NULL when tabs are detached.
   views::Widget* widget = view->GetWidget();
   return chrome::GetHostDesktopTypeForNativeView(
       widget ? widget->GetNativeView() : NULL);
 }
 
+// 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();
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
 class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
@@ skipping 276 matching lines @@
     ResetCrashedFavicon();
   }
 
   if (data_.media_state != old.media_state) {
     if (data_.media_state != TAB_MEDIA_STATE_NONE)
       animating_media_state_ = data_.media_state;
     StartMediaIndicatorAnimation();
   }
 
   if (old.mini != data_.mini) {
-    if (tab_animation_.get() && tab_animation_->is_animating()) {
-      tab_animation_->Stop();
-      tab_animation_.reset(NULL);
-    }
+    StopAndDeleteAnimation(
+        mini_title_change_animation_.PassAs<gfx::Animation>());
   }
 
   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;
   }
 
   TabRendererData::NetworkState old_state = data_.network_state;
   data_.network_state = state;
   AdvanceLoadingAnimation(old_state, state);
 }
 
 void Tab::StartPulse() {
-  gfx::ThrobAnimation* animation = new gfx::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);
+  pulse_animation_.reset(new gfx::ThrobAnimation(this));
+  pulse_animation_->SetSlideDuration(kPulseDurationMs);
+  if (animation_container_)
+    pulse_animation_->SetContainer(animation_container_.get());
+  pulse_animation_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 void Tab::StopPulse() {
-  if (!tab_animation_.get())
-    return;
-  tab_animation_->Stop();
-  tab_animation_.reset(NULL);
+  StopAndDeleteAnimation(pulse_animation_.PassAs<gfx::Animation>());
 }
 
 void Tab::StartMiniTabTitleAnimation() {
-  // 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()) {
+  if (!mini_title_change_animation_) {
     gfx::MultiAnimation::Parts parts;
     parts.push_back(
         gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration1MS,
                                  gfx::Tween::EASE_OUT));
     parts.push_back(
         gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration2MS,
                                  gfx::Tween::ZERO));
     parts.push_back(
         gfx::MultiAnimation::Part(kMiniTitleChangeAnimationDuration3MS,
                                  gfx::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;
     base::TimeDelta timeout =
         base::TimeDelta::FromMilliseconds(kMiniTitleChangeAnimationIntervalMS);
-    gfx::MultiAnimation* animation = new gfx::MultiAnimation(parts, timeout);
-    if (animation_container_.get())
-      animation->SetContainer(animation_container_.get());
-    animation->set_delegate(this);
-    tab_animation_.reset(animation);
+    mini_title_change_animation_.reset(new gfx::MultiAnimation(parts, timeout));
+    if (animation_container_)
+      mini_title_change_animation_->SetContainer(animation_container_.get());
+    mini_title_change_animation_->set_delegate(this);
   }
-  tab_animation_->Start();
+  mini_title_change_animation_->Start();
 }
 
 void Tab::StopMiniTabTitleAnimation() {
-  if (!tab_animation_.get())
-    return;
-  tab_animation_->Stop();
-  tab_animation_.reset(NULL);
+  StopAndDeleteAnimation(mini_title_change_animation_.PassAs<gfx::Animation>());
 }
 
 // static
 gfx::Size Tab::GetBasicMinimumUnselectedSize() {
   InitTabResources();
 
   gfx::Size minimum_size;
   minimum_size.set_width(kLeftPadding + kRightPadding);
   // Since we use image images, the real minimum height of the image is
   // defined most accurately by the height of the end cap images.
@@ skipping 35 matching lines @@
 int Tab::GetImmersiveHeight() {
   return kImmersiveTabHeight;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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 == tab_animation_.get() && IsActive())
+  if (animation == pulse_animation_.get() && IsActive())
     return;
   SchedulePaint();
 }
 
 void Tab::AnimationCanceled(const gfx::Animation* animation) {
   if (media_indicator_animation_ == animation)
     animating_media_state_ = data_.media_state;
   SchedulePaint();
 }
 
@@ skipping 410 matching lines @@
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     close_button_->SetBackground(close_button_color_,
         rb.GetImageSkiaNamed(IDR_CLOSE_1),
         rb.GetImageSkiaNamed(IDR_CLOSE_1_MASK));
   }
 }
 
 void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
   // Use transparency for the draw-attention animation.
   int alpha = 255;
-  if (tab_animation_ &&
-      tab_animation_->is_animating() &&
-      !data().mini) {
-    alpha = tab_animation_->CurrentValueBetween(
+  if (pulse_animation_ && pulse_animation_->is_animating() && !data().mini) {
+    alpha = pulse_animation_->CurrentValueBetween(
         255, static_cast<int>(255 * kImmersiveTabMinThrobOpacity));
   }
 
   // Draw a gray rectangle to represent the tab. This works for mini-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));
 
@@ skipping 23 matching lines @@
           bar_rect.x(), 0, left_eye_width, kImmersiveBarHeight);
       canvas->FillRect(left_eye_rect, kEyeColor);
     }
   }
 }
 
 void Tab::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsActive()) {
     PaintActiveTabBackground(canvas);
   } else {
-    if (tab_animation_.get() &&
-        tab_animation_->is_animating() &&
-        data().mini) {
-      gfx::MultiAnimation* animation =
-          static_cast<gfx::MultiAnimation*>(tab_animation_.get());
-      PaintInactiveTabBackgroundWithTitleChange(canvas, animation);
+    if (mini_title_change_animation_ &&
+        mini_title_change_animation_->is_animating()) {
+      PaintInactiveTabBackgroundWithTitleChange(canvas);
     } 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,
-    gfx::MultiAnimation* animation) {
+void Tab::PaintInactiveTabBackgroundWithTitleChange(gfx::Canvas* canvas) {
   // Render the inactive tab background. We'll use this for clipping.
   gfx::Canvas background_canvas(size(), canvas->image_scale(), false);
   PaintInactiveTabBackground(&background_canvas);
 
   gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
 
   // Draw a radial gradient to hover_canvas.
   gfx::Canvas hover_canvas(size(), canvas->image_scale(), false);
   int radius = kMiniTitleChangeGradientRadius;
   int x0 = width() + radius - kMiniTitleChangeInitialXOffset;
   int x1 = radius;
   int x2 = -radius;
   int x;
-  if (animation->current_part_index() == 0) {
-    x = animation->CurrentValueBetween(x0, x1);
-  } else if (animation->current_part_index() == 1) {
+  if (mini_title_change_animation_->current_part_index() == 0) {
+    x = mini_title_change_animation_->CurrentValueBetween(x0, x1);
+  } else if (mini_title_change_animation_->current_part_index() == 1) {
     x = x1;
   } else {
-    x = animation->CurrentValueBetween(x1, x2);
+    x = mini_title_change_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 (animation->current_part_index() == 2) {
-    uint8 alpha = animation->CurrentValueBetween(255, 0);
+  if (mini_title_change_animation_->current_part_index() == 2) {
+    uint8 alpha = mini_title_change_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;
   int frame_id;
   views::Widget* widget = GetWidget();
@@ skipping 292 matching lines @@
       IconCapacity(), data().mini, IsActive(), data().show_icon,
       animating_media_state_);
 }
 
 bool Tab::ShouldShowCloseBox() const {
   return chrome::ShouldTabShowCloseButton(
       IconCapacity(), data().mini, IsActive());
 }
 
 double Tab::GetThrobValue() {
-  bool is_selected = IsSelected();
-  double min = is_selected ? kSelectedTabOpacity : 0;
-  double scale = is_selected ? kSelectedTabThrobScale : 1;
+  const bool is_selected = IsSelected();
+  const double min = is_selected ? kSelectedTabOpacity : 0;
+  const double scale = is_selected ? kSelectedTabThrobScale : 1;
 
-  if (!data().mini) {
-    if (tab_animation_.get() && tab_animation_->is_animating())
-      return tab_animation_->GetCurrentValue() * kHoverOpacity * scale + min;
+  // Showing both the pulse and title change animation at the same time is too
+  // much.
+  if (pulse_animation_ && pulse_animation_->is_animating() &&
+      (!mini_title_change_animation_ ||
+       !mini_title_change_animation_->is_animating())) {
+    return pulse_animation_->GetCurrentValue() * kHoverOpacity * scale + min;
   }
 
   if (hover_controller_.ShouldDraw()) {
     return kHoverOpacity * hover_controller_.GetAnimationValue() * scale +
         min;
   }
 
   return is_selected ? kSelectedTabOpacity : 0;
 }
 
@@ skipping 126 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();
 }