Makes inactive pinned tabs throb on views when the title changes....

chrome/browser/views/tabs/tab_renderer.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/views/tabs/tab_renderer.h"
 
 #include <limits>
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/favicon_size.h"
 #include "app/gfx/font.h"
 #include "app/gfx/skbitmap_operations.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
+#include "app/slide_animation.h"
+#include "app/throb_animation.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/widget/widget.h"
@@ skipping 46 matching lines @@
 static SkBitmap* loading_animation_frames = NULL;
 static SkBitmap* crashed_fav_icon = NULL;
 static int loading_animation_frame_count = 0;
 static int waiting_animation_frame_count = 0;
 static int waiting_to_loading_frame_count_ratio = 0;
 
 TabRenderer::TabImage TabRenderer::tab_alpha = {0};
 TabRenderer::TabImage TabRenderer::tab_active = {0};
 TabRenderer::TabImage TabRenderer::tab_inactive = {0};
 
+// Max opacity for the pinned tab title change animation.
+const double kPinnedThrobOpacity = 0.75;
+
+// Duration for when the title of an inactive pinned tab changes.
+const int kPinnedDuration = 1000;
+
 namespace {
 
 void InitResources() {
   static bool initialized = false;
   if (!initialized) {
     // TODO(glen): Allow theming of these.
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     title_font = new gfx::Font(rb.GetFont(ResourceBundle::BaseFont));
     title_font_height = title_font->height();
 
@@ skipping 263 matching lines @@
 void TabRenderer::StartPulse() {
   pulse_animation_->Reset();
   pulse_animation_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 void TabRenderer::StopPulse() {
   if (pulse_animation_->IsAnimating())
     pulse_animation_->Stop();
 }
 
+void TabRenderer::StartPinnedTabTitleAnimation() {
+  if (!pinned_title_animation_.get()) {
+    pinned_title_animation_.reset(new ThrobAnimation(this));
+    pinned_title_animation_->SetThrobDuration(kPinnedDuration);
+  }
+
+  if (!pinned_title_animation_->IsAnimating()) {
+    pinned_title_animation_->StartThrobbing(2);
+  } else if (pinned_title_animation_->cycles_remaining() <= 2) {
+    // The title changed while we're already animating. Add at most one more
+    // cycle. This is done in an attempt to smooth out pages that continuously
+    // change the title.
+    pinned_title_animation_->set_cycles_remaining(
+        pinned_title_animation_->cycles_remaining() + 2);
+  }
+}
+
+void TabRenderer::StopPinnedTabTitleAnimation() {
+  if (pinned_title_animation_.get())
+    pinned_title_animation_->Stop();
+}
+
 // static
 gfx::Size TabRenderer::GetMinimumUnselectedSize() {
   InitResources();
 
   gfx::Size minimum_size;
   minimum_size.set_width(kLeftPadding + kRightPadding);
   // Since we use bitmap images, the real minimum height of the image is
   // defined most accurately by the height of the end cap images.
   minimum_size.set_height(tab_active.image_l->height());
   return minimum_size;
@@ skipping 229 matching lines @@
   }
 }
 
 void TabRenderer::PaintTabBackground(gfx::Canvas* canvas) {
   if (IsSelected()) {
     // Sometimes detaching a tab quickly can result in the model reporting it
     // as not being selected, so is_drag_clone_ ensures that we always paint
     // the active representation for the dragged tab.
     PaintActiveTabBackground(canvas);
   } else {
-    // Draw our hover state.
-    Animation* animation = hover_animation_.get();
-    if (pulse_animation_->IsAnimating())
-      animation = pulse_animation_.get();
+    PaintInactiveTabBackground(canvas);
 
-    PaintInactiveTabBackground(canvas);
-    if (animation->GetCurrentValue() > 0) {
+    double throb_value = GetThrobValue();
+    if (throb_value > 0) {
       SkRect bounds;
       bounds.set(0, 0, SkIntToScalar(width()), SkIntToScalar(height()));
-      canvas->saveLayerAlpha(&bounds,
-          static_cast<int>(animation->GetCurrentValue() * kHoverOpacity * 0xff),
-              SkCanvas::kARGB_ClipLayer_SaveFlag);
+      canvas->saveLayerAlpha(&bounds, static_cast<int>(throb_value * 0xff),
+                             SkCanvas::kARGB_ClipLayer_SaveFlag);
       canvas->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
       PaintActiveTabBackground(canvas);
       canvas->restore();
     }
   }
 }
 
 void TabRenderer::PaintInactiveTabBackground(gfx::Canvas* canvas) {
   bool is_otr = data_.off_the_record;
 
@@ skipping 156 matching lines @@
   }
   // Non-selected tabs clip close button before favicon.
   return IconCapacity() >= 1;
 }
 
 bool TabRenderer::ShouldShowCloseBox() const {
   // The selected tab never clips close button.
   return !pinned() && (IsSelected() || IconCapacity() >= 3);
 }
 
+double TabRenderer::GetThrobValue() {
+  if (pulse_animation_->IsAnimating())
+    return pulse_animation_->GetCurrentValue() * kHoverOpacity;
+
+  if (pinned_title_animation_.get() && pinned_title_animation_->IsAnimating())
+    return pinned_title_animation_->GetCurrentValue() * kPinnedThrobOpacity;
+
+  return hover_animation_.get() ?
+      kHoverOpacity * hover_animation_->GetCurrentValue() : 0;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TabRenderer, private:
 
 void TabRenderer::StartCrashAnimation() {
   if (!crash_animation_)
     crash_animation_ = new FavIconCrashAnimation(this);
   crash_animation_->Reset();
   crash_animation_->Start();
 }
 
@@ skipping 37 matching lines @@
   tab_inactive.image_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
   tab_inactive.image_c = rb.GetBitmapNamed(IDR_TAB_INACTIVE_CENTER);
   tab_inactive.image_r = rb.GetBitmapNamed(IDR_TAB_INACTIVE_RIGHT);
 
   tab_inactive.l_width = tab_inactive.image_l->width();
   tab_inactive.r_width = tab_inactive.image_r->width();
 
   loading_animation_frames = rb.GetBitmapNamed(IDR_THROBBER);
   waiting_animation_frames = rb.GetBitmapNamed(IDR_THROBBER_WAITING);
 }