Implement the sad tab crash animation for tabs in linux.

chrome/browser/gtk/tabs/tab_renderer_gtk.cc

 // Copyright (c) 2009 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/gtk/tabs/tab_renderer_gtk.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
@@ skipping 25 matching lines @@
 
 const SkScalar kTabCapWidth = 15;
 const SkScalar kTabTopCurveWidth = 4;
 const SkScalar kTabBottomCurveWidth = 3;
 
 // The vertical and horizontal offset used to position the close button
 // in the tab. TODO(jhawkins): Ask pkasting what the Fuzz is about.
 const int kCloseButtonVertFuzz = 0;
 const int kCloseButtonHorzFuzz = 5;
 
+SkBitmap* crashed_fav_icon = NULL;
+
 TabRendererGtk::LoadingAnimation::Data loading_animation_data;
 
 // Loads the loading animation images and data.
 void InitializeLoadingAnimationData(
     ResourceBundle* rb, TabRendererGtk::LoadingAnimation::Data* data) {
   // The loading animation image is a strip of states. Each state must be
   // square, so the height must divide the width evenly.
   data->loading_animation_frames = rb->GetBitmapNamed(IDR_THROBBER);
   DCHECK(data->loading_animation_frames);
   DCHECK_EQ(data->loading_animation_frames->width() %
@@ skipping 63 matching lines @@
     animation_frame_ = ++animation_frame_ %
                        ((animation_state_ == ANIMATION_WAITING) ?
                          data_->waiting_animation_frame_count :
                          data_->loading_animation_frame_count);
   } else {
     animation_frame_ = 0;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// FaviconCrashAnimation
+//
+//  A custom animation subclass to manage the favicon crash animation.
+class TabRendererGtk::FavIconCrashAnimation : public Animation,
+                                              public AnimationDelegate {
+ public:
+  explicit FavIconCrashAnimation(TabRendererGtk* target)
+      : ALLOW_THIS_IN_INITIALIZER_LIST(Animation(1000, 25, this)),
+        target_(target) {
+  }
+  virtual ~FavIconCrashAnimation() {}
+
+  // Animation overrides:
+  virtual void AnimateToState(double state) {
+    const double kHidingOffset = 27;
+
+    if (state < .5) {
+      target_->SetFavIconHidingOffset(
+          static_cast<int>(floor(kHidingOffset * 2.0 * state)));
+    } else {
+      target_->DisplayCrashedFavIcon();
+      target_->SetFavIconHidingOffset(
+          static_cast<int>(
+              floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
+    }
+  }
+
+  // AnimationDelegate overrides:
+  virtual void AnimationCanceled(const Animation* animation) {
+    target_->SetFavIconHidingOffset(0);
+  }
+
+ private:
+  TabRendererGtk* target_;
+
+  DISALLOW_COPY_AND_ASSIGN(FavIconCrashAnimation);
+};
+
+////////////////////////////////////////////////////////////////////////////////
 // TabRendererGtk, public:
 
 TabRendererGtk::TabRendererGtk()
     : showing_icon_(false),
       showing_download_icon_(false),
       showing_close_button_(false),
       fav_icon_hiding_offset_(0),
       should_display_crashed_favicon_(false),
       loading_animation_(&loading_animation_data) {
   InitResources();
@@ skipping 26 matching lines @@
   // we display the throbber.
   data_.loading = contents->is_loading();
   data_.show_icon = contents->ShouldDisplayFavIcon();
 
   theme_provider_ = contents->profile()->GetThemeProvider();
 }
 
 void TabRendererGtk::UpdateFromModel() {
   // Force a layout, since the tab may have grown a favicon.
   Layout();
+  SchedulePaint();
+
+  if (data_.crashed) {
+    if (!should_display_crashed_favicon_ && !IsPerformingCrashAnimation())
+      StartCrashAnimation();
+  } else {
+    if (IsPerformingCrashAnimation())
+      StopCrashAnimation();
+    ResetCrashedFavIcon();
+  }
 }
 
 bool TabRendererGtk::IsSelected() const {
   return true;
 }
 
 bool TabRendererGtk::IsVisible() const {
   return GTK_WIDGET_FLAGS(tab_.get()) & GTK_VISIBLE;
 }
 
@@ skipping 98 matching lines @@
   AnimationEnded(animation);
 }
 
 void TabRendererGtk::AnimationEnded(const Animation* animation) {
   gtk_widget_queue_draw(tab_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TabRendererGtk, private:
 
+void TabRendererGtk::StartCrashAnimation() {
+  if (!crash_animation_.get())
+    crash_animation_.reset(new FavIconCrashAnimation(this));
+  crash_animation_->Reset();
+  crash_animation_->Start();
+}
+
+void TabRendererGtk::StopCrashAnimation() {
+  if (!crash_animation_.get())
+    return;
+  crash_animation_->Stop();
+}
+
+bool TabRendererGtk::IsPerformingCrashAnimation() const {
+  return crash_animation_.get() && crash_animation_->IsAnimating();
+}
+
+void TabRendererGtk::SetFavIconHidingOffset(int offset) {
+  fav_icon_hiding_offset_ = offset;
+  SchedulePaint();
+}
+
+void TabRendererGtk::DisplayCrashedFavIcon() {
+  should_display_crashed_favicon_ = true;
+}
+
+void TabRendererGtk::ResetCrashedFavIcon() {
+  should_display_crashed_favicon_ = false;
+}
+
 void TabRendererGtk::Paint(GdkEventExpose* event) {
   gfx::CanvasPaint canvas(event, false);
   if (canvas.isEmpty())
     return;
 
   // Don't paint if we're narrower than we can render correctly. (This should
   // only happen during animations).
   if (width() < GetMinimumUnselectedSize().width())
     return;
 
   // See if the model changes whether the icons should be painted.
   const bool show_icon = ShouldShowIcon();
   const bool show_download_icon = data_.show_download_icon;
   const bool show_close_button = ShouldShowCloseBox();
   if (show_icon != showing_icon_ ||
       show_download_icon != showing_download_icon_ ||
       show_close_button != showing_close_button_)
     Layout();
 
   PaintTabBackground(&canvas);
 
   if (show_icon) {
     if (loading_animation_.animation_state() != ANIMATION_NONE) {
       PaintLoadingAnimation(&canvas);
-    } else if (!data_.favicon.isNull()) {
-      canvas.DrawBitmapInt(data_.favicon, favicon_bounds_.x(),
-                           favicon_bounds_.y() + fav_icon_hiding_offset_);
+    } else {
+      canvas.save();
+      canvas.ClipRectInt(0, 0, width(), height() - kFavIconTitleSpacing);
+      if (should_display_crashed_favicon_) {
+        canvas.DrawBitmapInt(*crashed_fav_icon, 0, 0,
+                             crashed_fav_icon->width(),
+                             crashed_fav_icon->height(),
+                             favicon_bounds_.x(),
+                             favicon_bounds_.y() + fav_icon_hiding_offset_,
+                             kFavIconSize, kFavIconSize,
+                             true);
+      } else {
+        if (!data_.favicon.isNull()) {
+          // TODO(pkasting): Use code in tab_icon_view.cc:PaintIcon() (or switch
+          // to using that class to render the favicon).
+          canvas.DrawBitmapInt(data_.favicon, 0, 0,
+                               data_.favicon.width(),
+                               data_.favicon.height(),
+                               favicon_bounds_.x(),
+                               favicon_bounds_.y() + fav_icon_hiding_offset_,
+                               kFavIconSize, kFavIconSize,
+                               true);
+        }
+      }
+      canvas.restore();
     }
   }
 
   if (show_download_icon) {
     canvas.DrawBitmapInt(*download_icon_,
                          download_icon_bounds_.x(), download_icon_bounds_.y());
   }
 
   // Paint the Title.
   std::wstring title = data_.title;
@@ skipping 270 matching lines @@
   LoadTabImages();
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   // Force the font size to 10pt.
   gfx::Font base_font = rb.GetFont(ResourceBundle::BaseFont);
   title_font_ = new gfx::Font(gfx::Font::CreateFont(base_font.FontName(), 10));
   title_font_height_ = title_font_->height();
 
   InitializeLoadingAnimationData(&rb, &loading_animation_data);
 
+  crashed_fav_icon = rb.GetBitmapNamed(IDR_SAD_FAVICON);
+
   initialized_ = true;
 }