Implement upgrade notifications....

chrome/browser/views/toolbar_view.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/views/toolbar_view.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
+#include "chrome/browser/upgrade_detector.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/bookmark_menu_button.h"
 #include "chrome/browser/views/browser_actions_container.h"
 #include "chrome/browser/views/event_utils.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "gfx/canvas.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#include "gfx/skbitmap_operations.h"
 #include "grit/theme_resources.h"
 #include "views/controls/button/button_dropdown.h"
 #include "views/focus/view_storage.h"
 #include "views/widget/tooltip_manager.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
 static const int kControlHorizOffset = 4;
 static const int kControlVertOffset = 6;
 static const int kControlIndent = 3;
 static const int kStatusBubbleWidth = 480;
 
+// The length of time to run the upgrade notification animation (the time it
+// takes one pulse to run its course and go back to its original brightness).
+static const int kPulseDuration = 2000;
+
+// How long to wait between pulsating the upgrade notifier.
+static const int kPulsateEveryMs = 8000;
+
+// The offset in pixels of the upgrade dot on the app menu.
+static const int kUpgradeDotOffset = 11;
+
 // Separation between the location bar and the menus.
 static const int kMenuButtonOffset = 3;
 
 // Padding to the right of the location bar
 static const int kPaddingRight = 2;
 
 static const int kPopupTopSpacingNonGlass = 3;
 static const int kPopupBottomSpacingNonGlass = 2;
 static const int kPopupBottomSpacingGlass = 1;
 
@@ skipping 33 matching lines @@
 
   if (browser->SupportsWindowFeature(Browser::FEATURE_TABSTRIP))
     display_mode_ = DISPLAYMODE_NORMAL;
   else
     display_mode_ = DISPLAYMODE_LOCATION;
 
   if (!kPopupBackgroundEdge) {
     kPopupBackgroundEdge = ResourceBundle::GetSharedInstance().GetBitmapNamed(
         IDR_LOCATIONBG_POPUPMODE_EDGE);
   }
+
+  if (!Singleton<UpgradeDetector>::get()->notify_upgrade()) {
+    registrar_.Add(this,
+        NotificationType::UPGRADE_RECOMMENDED,
+        NotificationService::AllSources());
+  }
 }
 
 ToolbarView::~ToolbarView() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
   if (menu_bar_emulation_mode_) {
     focus_manager_->UnregisterAccelerators(this);
     focus_manager_->RemoveFocusChangeListener(this);
   }
 }
@@ skipping 171 matching lines @@
 
 void ToolbarView::OnInputInProgress(bool in_progress) {
   // The edit should make sure we're only notified when something changes.
   DCHECK(model_->input_in_progress() != in_progress);
 
   model_->set_input_in_progress(in_progress);
   location_bar_->Update(NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// ToolbarView, AnimationDelegate implementation:
+
+void ToolbarView::AnimationProgressed(const Animation* animation) {
+  app_menu_->SetIcon(GetAppMenuIcon());
+  SchedulePaint();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, CommandUpdater::CommandObserver implementation:
 
 void ToolbarView::EnabledStateChangedForCommand(int id, bool enabled) {
   views::Button* button = NULL;
   switch (id) {
     case IDC_BACK:
       button = back_;
       break;
     case IDC_FORWARD:
       button = forward_;
@@ skipping 40 matching lines @@
 
 void ToolbarView::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (type == NotificationType::PREF_CHANGED) {
     std::wstring* pref_name = Details<std::wstring>(details).ptr();
     if (*pref_name == prefs::kShowHomeButton) {
       Layout();
       SchedulePaint();
     }
+  } else if (type == NotificationType::UPGRADE_RECOMMENDED) {
+    ShowUpgradeReminder();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, menus::SimpleMenuModel::Delegate implementation:
 
 bool ToolbarView::IsCommandIdChecked(int command_id) const {
   if (command_id == IDC_SHOW_BOOKMARK_BAR)
     return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   return false;
@@ skipping 305 matching lines @@
       l10n_util::GetString(IDS_PRODUCT_NAME)));
   app_menu_->SetID(VIEW_ID_APP_MENU);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kBookmarkMenu)) {
     bookmark_menu_ = new BookmarkMenuButton(browser_);
     AddChildView(bookmark_menu_);
   } else {
     bookmark_menu_ = NULL;
   }
 
+  // Catch the case where the window is created after we detect a new version.
+  if (Singleton<UpgradeDetector>::get()->notify_upgrade())
+    ShowUpgradeReminder();
+
   LoadRightSideControlsImages();
 
   AddChildView(browser_actions_);
   AddChildView(page_menu_);
   AddChildView(app_menu_);
 }
 
 void ToolbarView::LoadLeftSideControlsImages() {
   ThemeProvider* tp = GetThemeProvider();
 
@@ skipping 49 matching lines @@
   go_->SetToggledImage(views::CustomButton::BS_NORMAL,
       tp->GetBitmapNamed(IDR_STOP));
   go_->SetToggledImage(views::CustomButton::BS_HOT,
       tp->GetBitmapNamed(IDR_STOP_H));
   go_->SetToggledImage(views::CustomButton::BS_PUSHED,
       tp->GetBitmapNamed(IDR_STOP_P));
   go_->SetBackground(color, background,
       tp->GetBitmapNamed(IDR_GO_MASK));
 }
 
+void ToolbarView::ShowUpgradeReminder() {
+  update_reminder_animation_.reset(new SlideAnimation(this));
+  update_reminder_animation_->SetSlideDuration(kPulseDuration);
+
+  // Then start the recurring timer for pulsating it.
+  upgrade_reminder_pulse_timer_.Start(
+      base::TimeDelta::FromMilliseconds(kPulsateEveryMs),
+      this, &ToolbarView::PulsateUpgradeNotifier);
+}
+
+void ToolbarView::PulsateUpgradeNotifier() {
+  // Start the pulsating animation.
+  update_reminder_animation_->Reset(0.0);
+  update_reminder_animation_->Show();
+}
+
+SkBitmap ToolbarView::GetAppMenuIcon() {
+  ThemeProvider* tp = GetThemeProvider();
+
+  SkBitmap icon;
+
+  // We use different menu button images if the locale is right-to-left.
+  if (base::i18n::IsRTL())
+    icon = *tp->GetBitmapNamed(IDR_MENU_CHROME_RTL);
+  else
+    icon = *tp->GetBitmapNamed(IDR_MENU_CHROME);
+
+  if (!Singleton<UpgradeDetector>::get()->notify_upgrade())
+    return icon;
+
+  // Draw the chrome app menu icon onto the canvas.
+  scoped_ptr<gfx::Canvas> canvas(
+      new gfx::Canvas(icon.width(), icon.height(), false));
+  canvas->DrawBitmapInt(icon, 0, 0);
+
+  SkBitmap badge;
+
+  static bool has_faded_in = false;
+  if (!has_faded_in) {
+    SkBitmap* dot = tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE);
+    SkBitmap transparent;
+    transparent.setConfig(dot->getConfig(), dot->width(), dot->height());
+    transparent.allocPixels();
+    transparent.eraseARGB(0, 0, 0, 0);
+    badge = SkBitmapOperations::CreateBlendedBitmap(
+        *dot, transparent, 1.0 - update_reminder_animation_->GetCurrentValue());
+    if (update_reminder_animation_->GetCurrentValue() == 1.0)
+      has_faded_in = true;
+  } else {
+    // Convert animation values that start from 0.0 and incrementally go
+    // up to 1.0 into values that start in 0.0, go to 1.0 and then back
+    // to 0.0 (to create a pulsing effect).
+    double value = 1.0 -
+                   abs(2.0 * update_reminder_animation_->GetCurrentValue() -
+                       1.0);
+
+    // Add the badge to it.
+    badge = SkBitmapOperations::CreateBlendedBitmap(
+        *tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE),
+        *tp->GetBitmapNamed(IDR_UPGRADE_DOT_ACTIVE),
+        value);
+  }
+
+  int x_pos = kUpgradeDotOffset;
+  if (base::i18n::IsRTL())
+    x_pos = icon.width() - badge.width();
+  canvas->DrawBitmapInt(badge, x_pos, icon.height() - badge.height());
+
+  return canvas->ExtractBitmap();
+}
+
 void ToolbarView::LoadRightSideControlsImages() {
   ThemeProvider* tp = GetThemeProvider();
 
   // We use different menu button images if the locale is right-to-left.
   if (base::i18n::IsRTL())
     page_menu_->SetIcon(*tp->GetBitmapNamed(IDR_MENU_PAGE_RTL));
   else
     page_menu_->SetIcon(*tp->GetBitmapNamed(IDR_MENU_PAGE));
-  if (base::i18n::IsRTL())
-    app_menu_->SetIcon(*tp->GetBitmapNamed(IDR_MENU_CHROME_RTL));
-  else
-    app_menu_->SetIcon(*tp->GetBitmapNamed(IDR_MENU_CHROME));
+
+  app_menu_->SetIcon(GetAppMenuIcon());
 
   if (bookmark_menu_ != NULL)
     bookmark_menu_->SetIcon(*tp->GetBitmapNamed(IDR_MENU_BOOKMARK));
 }
 
 void ToolbarView::RunPageMenu(const gfx::Point& pt) {
   bool destroyed_flag = false;
   destroyed_flag_ = &destroyed_flag;
 
   page_menu_model_.reset(new PageMenuModel(this, browser_));
@@ skipping 23 matching lines @@
   for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
     app_menu_menu_->AddMenuListener(menu_listeners_[i]);
   }
   app_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
 
   if (destroyed_flag)
     return;
 
   destroyed_flag_ = NULL;
 
+  // Stop pulsating the upgrade reminder on the app menu, if active.
+  upgrade_reminder_pulse_timer_.Stop();
+
   for (unsigned int i = 0; i < menu_listeners_.size(); i++) {
     app_menu_menu_->RemoveMenuListener(menu_listeners_[i]);
   }
   SwitchToOtherMenuIfNeeded(app_menu_menu_.get(), page_menu_);
 }
 
 void ToolbarView::SwitchToOtherMenuIfNeeded(
     views::Menu2* previous_menu, views::MenuButton* next_menu_button) {
   // If the user tried to move to the right or left, switch from the
   // app menu to the page menu. Switching to the next menu is delayed
@@ skipping 59 matching lines @@
     last_focused_view->RequestFocus();
   } else {
     // Focus the location bar
     views::View* view = GetAncestorWithClassName(BrowserView::kViewClassName);
     if (view) {
       BrowserView* browser_view = static_cast<BrowserView*>(view);
       browser_view->SetFocusToLocationBar(false);
     }
   }
 }