Fix favicon crash animation.

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 147 matching lines @@
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
       : gfx::LinearAnimation(1000, 25, this),
         target_(target) {
   }
   ~FaviconCrashAnimation() override {}
 
   // gfx::Animation overrides:
   void AnimateToState(double state) override {
-    const double kHidingOffset = 27;
+    const double kHidingOffset =
+        Tab::GetMinimumInactiveSize().height() - GetLayoutInsets(TAB).height();
 
     if (state < .5) {
       // Animate the normal icon down.
       target_->SetFaviconHidingOffset(
           static_cast<int>(floor(kHidingOffset * 2.0 * state)));
     } else {
       // Animate the crashed icon up.
-      target_->DisplayCrashedFavicon();
+      target_->set_should_display_crashed_favicon();
       target_->SetFaviconHidingOffset(
           static_cast<int>(
               floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
     }
   }
 
-  // gfx::AnimationDelegate overrides:
-  void AnimationCanceled(const gfx::Animation* animation) override {
-    target_->SetFaviconHidingOffset(0);
-  }
-
  private:
   Tab* target_;
 
   DISALLOW_COPY_AND_ASSIGN(FaviconCrashAnimation);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabCloseButton
 //
 //  This is a Button subclass that causes middle clicks to be forwarded to the
@@ skipping 266 matching lines @@
   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_ && !IsPerformingCrashAnimation()) {
+    if (!should_display_crashed_favicon_ && !crash_icon_animation_) {
       data_.media_state = TAB_MEDIA_STATE_NONE;
+      bool start_crash_animation = true;
 #if defined(OS_CHROMEOS)
       // On Chrome OS, we reload killed tabs automatically when the user
       // switches to them.  Don't display animations for these unless they're
       // selected (i.e. in the foreground) -- we won't reload these
       // automatically since we don't want to get into a crash loop.
-      if (IsSelected() ||
-          (data_.crashed_status
-           != base::TERMINATION_STATUS_PROCESS_WAS_KILLED &&
-           data_.crashed_status
-           != base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM)) {
-        StartCrashAnimation();
+      start_crash_animation = IsSelected() ||
+          (data_.crashed_status !=
+              base::TERMINATION_STATUS_PROCESS_WAS_KILLED &&
+           data_.crashed_status !=
+              base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM));
+#endif
+      if (start_crash_animation) {
+        crash_icon_animation_.reset(new FaviconCrashAnimation(this));
+        crash_icon_animation_->Start();
       }
-#else
-      StartCrashAnimation();
-#endif
     }
   } else {
-    if (IsPerformingCrashAnimation())
-      StopCrashAnimation();
-    ResetCrashedFavicon();
+    if (crash_icon_animation_)
+        crash_icon_animation_.reset();
+    should_display_crashed_favicon_ = false;
+    favicon_hiding_offset_ = 0;
   }
 
   if (data_.media_state != old.media_state)
     media_indicator_button_->TransitionToMediaState(data_.media_state);
 
-  if (old.pinned != data_.pinned) {
-    StopAndDeleteAnimation(pinned_title_change_animation_.Pass());
-  }
+  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) {
@@ skipping 826 matching lines @@
 
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawImageInt(*tab_image->image_l, 0, 0);
   canvas->TileImageInt(*tab_image->image_c, tab_image->l_width, 0,
       width() - tab_image->l_width - tab_image->r_width, height());
   canvas->DrawImageInt(*tab_image->image_r, width() - tab_image->r_width, 0);
 }
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
   gfx::Rect bounds = favicon_bounds_;
+  bounds.set_x(GetMirroredXForRect(bounds));
+  bounds.Offset(0, favicon_hiding_offset_);
+  bounds.Intersect(GetInteriorBounds());
   if (bounds.IsEmpty())
     return;
 
-  bounds.set_x(GetMirroredXForRect(bounds));
-
-  if (data().network_state != TabRendererData::NETWORK_STATE_NONE) {
+  if (!should_display_crashed_favicon_ &&

[Peter Kasting, 2015/10/09 09:37:29]

Not sure I should add this; see CL description.

+      data().network_state != TabRendererData::NETWORK_STATE_NONE) {
     // Paint network activity (aka throbber) animation frame.
     ui::ThemeProvider* tp = GetThemeProvider();
     if (data().network_state == TabRendererData::NETWORK_STATE_WAITING) {
       if (waiting_start_time_ == base::TimeTicks())
         waiting_start_time_ = base::TimeTicks::Now();
 
       waiting_state_.elapsed_time =
           base::TimeTicks::Now() - waiting_start_time_;
       gfx::PaintThrobberWaiting(
           canvas, bounds, tp->GetColor(ThemeProperties::COLOR_THROBBER_WAITING),
@@ skipping 115 matching lines @@
   }
 
   return is_selected ? kSelectedTabOpacity : 0;
 }
 
 void Tab::SetFaviconHidingOffset(int offset) {
   favicon_hiding_offset_ = offset;
   ScheduleIconPaint();
 }
 
-void Tab::DisplayCrashedFavicon() {
-  should_display_crashed_favicon_ = true;
-}
-
-void Tab::ResetCrashedFavicon() {
-  should_display_crashed_favicon_ = false;
-}
-
-void Tab::StopCrashAnimation() {
-  crash_icon_animation_.reset();
-}
-
-void Tab::StartCrashAnimation() {
-  crash_icon_animation_.reset(new FaviconCrashAnimation(this));
-  crash_icon_animation_->Start();
-}
-
-bool Tab::IsPerformingCrashAnimation() const {
-  return crash_icon_animation_.get() && data_.IsCrashed();
-}
-
 void Tab::OnButtonColorMaybeChanged() {
   // The theme provider may be null if we're not currently in a widget
   // hierarchy.
   ui::ThemeProvider* theme_provider = GetThemeProvider();
   if (!theme_provider)
     return;
 
   const SkColor title_color = theme_provider->GetColor(IsActive() ?
       ThemeProperties::COLOR_TAB_TEXT :
       ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
   const SkColor new_button_color = SkColorSetA(title_color, 0xA0);
   if (button_color_ != new_button_color) {
     button_color_ = new_button_color;
     title_->SetEnabledColor(title_color);
     media_indicator_button_->OnParentTabButtonColorChanged();
     const gfx::ImageSkia& close_button_normal_image = gfx::CreateVectorIcon(
         gfx::VectorIconId::TAB_CLOSE_NORMAL, kTabCloseButtonSize,
         button_color_);
     close_button_->SetImage(views::CustomButton::STATE_NORMAL,
                             &close_button_normal_image);
   }
 }
 
 void Tab::ScheduleIconPaint() {
   gfx::Rect bounds = favicon_bounds_;
   if (bounds.IsEmpty())
     return;
 
-  // Extends the area to the bottom when sad_favicon is animating.
-  if (IsPerformingCrashAnimation())
+  // Extends the area to the bottom when the crash animation is in progress.
+  if (crash_icon_animation_)
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
 gfx::Rect Tab::GetInteriorBounds() const {
   gfx::Rect bounds(GetContentsBounds());
   bounds.Inset(GetLayoutInsets(TAB));
   return bounds;
 }
@@ skipping 82 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();
 }