GTK: reduce cpu usage of upgrade notification animation.

chrome/browser/gtk/browser_toolbar_gtk.cc

 // Copyright (c) 2010 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/browser_toolbar_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 #include <X11/XF86keysym.h>
 
@@ skipping 77 matching lines @@
       location_bar_(new LocationBarViewGtk(browser)),
       model_(browser->toolbar_model()),
       page_menu_model_(this, browser),
       app_menu_model_(this, browser),
       wrench_menu_model_(this, browser),
       browser_(browser),
       window_(window),
       profile_(NULL),
       menu_bar_helper_(this),
       upgrade_reminder_animation_(this),
+      upgrade_reminder_canceled_(false),
       collapsed_(false) {
   browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
   browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
   browser_->command_updater()->AddCommandObserver(IDC_HOME, this);
   browser_->command_updater()->AddCommandObserver(IDC_BOOKMARK_PAGE, this);
 
   registrar_.Add(this,
                  NotificationType::BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::UPGRADE_RECOMMENDED,
                  NotificationService::AllSources());
 
   upgrade_reminder_animation_.SetThrobDuration(kThrobDuration);
 
-  if (Singleton<UpgradeDetector>::get()->notify_upgrade())
-    ShowUpgradeReminder();
+  ActiveWindowWatcherX::AddObserver(this);
+  MaybeShowUpgradeReminder();
 }
 
 BrowserToolbarGtk::~BrowserToolbarGtk() {
+  ActiveWindowWatcherX::RemoveObserver(this);
+
   browser_->command_updater()->RemoveCommandObserver(IDC_BACK, this);
   browser_->command_updater()->RemoveCommandObserver(IDC_FORWARD, this);
   browser_->command_updater()->RemoveCommandObserver(IDC_HOME, this);
   browser_->command_updater()->RemoveCommandObserver(IDC_BOOKMARK_PAGE, this);
 
   offscreen_entry_.Destroy();
 
   page_menu_.reset();
   app_menu_.reset();
   page_menu_button_.Destroy();
@@ skipping 313 matching lines @@
     gtk_widget_set_size_request(location_hbox_, -1,
                                 use_gtk ? -1 : toolbar_height);
 
     // When using the GTK+ theme, we need to have the event box be visible so
     // buttons don't get a halo color from the background.  When using Chromium
     // themes, we want to let the background show through the toolbar.
     gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_), use_gtk);
 
     UpdateRoundedness();
   } else if (type == NotificationType::UPGRADE_RECOMMENDED) {
-    ShowUpgradeReminder();
+    MaybeShowUpgradeReminder();
   } else {
     NOTREACHED();
   }
 }
 
 // BrowserToolbarGtk, public ---------------------------------------------------
 
 void BrowserToolbarGtk::SetProfile(Profile* profile) {
   if (profile == profile_)
     return;
@@ skipping 276 matching lines @@
     }
   }
 
   if (!pref ||
       *pref == prefs::kHomePage ||
       *pref == prefs::kHomePageIsNewTabPage)
     SetUpDragForHomeButton(!home_page_.IsManaged() &&
                            !home_page_is_new_tab_page_.IsManaged());
 }
 
-void BrowserToolbarGtk::ShowUpgradeReminder() {
-  upgrade_reminder_animation_.StartThrobbing(-1);
+void BrowserToolbarGtk::MaybeShowUpgradeReminder() {
+  // Only show the upgrade reminder animation for the currently active window.
+  if (window_->IsActive() &&
+      Singleton<UpgradeDetector>::get()->notify_upgrade() &&
+      !upgrade_reminder_canceled_) {
+    upgrade_reminder_animation_.StartThrobbing(-1);
+  } else {
+    upgrade_reminder_animation_.Reset();
+  }
 }
 
 bool BrowserToolbarGtk::ShouldOnlyShowLocation() const {
   // If we're a popup window, only show the location bar (omnibox).
   return browser_->type() != Browser::TYPE_NORMAL;
 }
 
 void BrowserToolbarGtk::PopupForButton(GtkWidget* button) {
   if (page_menu_.get())
     page_menu_->Cancel();
@@ skipping 12 matching lines @@
                                              GtkMenuDirectionType dir) {
   GtkWidget* other_button = button == page_menu_button_.get() ?
       app_menu_button_.get() : page_menu_button_.get();
   // TODO(erg): When we move to wrench menu only, remove |menu_bar_helper_| so
   // this won't be necessary.
   if (other_button)
     PopupForButton(other_button);
 }
 
 void BrowserToolbarGtk::AnimationEnded(const Animation* animation) {
-  AnimationProgressed(animation);
+  DCHECK_EQ(animation, &upgrade_reminder_animation_);
+  gtk_widget_queue_draw(app_menu_image_.get());
 }
 
 void BrowserToolbarGtk::AnimationProgressed(const Animation* animation) {
   DCHECK_EQ(animation, &upgrade_reminder_animation_);
-  gtk_widget_queue_draw(app_menu_image_.get());
+
+  if (UpgradeAnimationIsFaded())
+    gtk_widget_queue_draw(app_menu_image_.get());
 }
 
 void BrowserToolbarGtk::AnimationCanceled(const Animation* animation) {
-  AnimationProgressed(animation);
+  AnimationEnded(animation);
+}
+
+void BrowserToolbarGtk::ActiveWindowChanged(GdkWindow* active_window) {
+  MaybeShowUpgradeReminder();
 }
 
 void BrowserToolbarGtk::OnAppMenuShow(GtkWidget* sender) {
-  upgrade_reminder_animation_.Reset();
+  if (upgrade_reminder_animation_.is_animating()) {
+    upgrade_reminder_canceled_ = true;
+    MaybeShowUpgradeReminder();
+  }
 }
 
 gboolean BrowserToolbarGtk::OnAppMenuImageExpose(GtkWidget* sender,
                                                  GdkEventExpose* expose) {
   if (!Singleton<UpgradeDetector>::get()->notify_upgrade())
     return FALSE;
 
   SkBitmap badge;
-  if (upgrade_reminder_animation_.cycles_remaining() > 0 &&
-      // This funky looking math makes the badge throb for 2 seconds once
-      // every 8 seconds.
-      ((upgrade_reminder_animation_.cycles_remaining() - 1) / 2) % 4 == 0) {
+  if (UpgradeAnimationIsFaded()) {
     badge = SkBitmapOperations::CreateBlendedBitmap(
         *theme_provider_->GetBitmapNamed(IDR_UPGRADE_DOT_ACTIVE),
         *theme_provider_->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE),
         upgrade_reminder_animation_.GetCurrentValue());
   } else {
     badge = *theme_provider_->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE);
   }
 
   // Draw the chrome app menu icon onto the canvas.
   gfx::CanvasSkiaPaint canvas(expose, false);
   int x_offset = base::i18n::IsRTL() ?
       sender->allocation.width - kUpgradeDotOffset - badge.width() :
       kUpgradeDotOffset;
   canvas.DrawBitmapInt(
       badge,
       sender->allocation.x + x_offset,
       sender->allocation.y + sender->allocation.height - badge.height());
 
   return FALSE;
 }
+
+bool BrowserToolbarGtk::UpgradeAnimationIsFaded() {
+  return upgrade_reminder_animation_.cycles_remaining() > 0 &&
+      // This funky looking math makes the badge throb for 2 seconds once
+      // every 8 seconds.
+      ((upgrade_reminder_animation_.cycles_remaining() - 1) / 2) % 4 == 0;
+}