Add an API to manipulate the browser action badge.

chrome/browser/views/browser_actions_container.cc

 // Copyright (c) 2006-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/browser_actions_container.h"
 
 #include "app/gfx/canvas.h"
 #include "app/resource_bundle.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
@@ skipping 31 matching lines @@
 class BrowserActionImageView : public views::TextButton,
                                public views::ButtonListener,
                                public ImageLoadingTracker::Observer,
                                public NotificationObserver {
  public:
   BrowserActionImageView(ExtensionAction* browser_action,
                          Extension* extension,
                          BrowserActionsContainer* panel);
   ~BrowserActionImageView();
 
+  ExtensionActionState* browser_action_state() { return browser_action_state_; }
+
   // Overridden from views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender, const views::Event& event);
 
   // Overridden from ImageLoadingTracker.
   virtual void OnImageLoaded(SkBitmap* image, size_t index);
 
   // Overridden from NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   // Called to update the display to match the browser action's state.
   void OnStateUpdated();
 
-  // Override painting to implement the badge.
-  virtual void Paint(gfx::Canvas* canvas);
-
   // The browser action this view represents. The ExtensionAction is not owned
   // by this class.
   ExtensionAction* browser_action_;
 
   // The state of our browser action. Not owned by this class.
   ExtensionActionState* browser_action_state_;
 
   // The icons representing different states for the browser action.
   std::vector<SkBitmap> browser_action_icons_;
 
@@ skipping 56 matching lines @@
     OnStateUpdated();
     tracker_ = NULL;  // The tracker object will delete itself when we return.
   }
 }
 
 void BrowserActionImageView::OnStateUpdated() {
   SkBitmap* image = &browser_action_icons_[browser_action_state_->icon_index()];
   SetIcon(*image);
   SetTooltipText(ASCIIToWide(browser_action_state_->title()));
   panel_->OnBrowserActionVisibilityChanged();
+  SchedulePaint();
 }
 
 void BrowserActionImageView::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   if (type == NotificationType::EXTENSION_BROWSER_ACTION_UPDATED) {
     OnStateUpdated();
   } else {
     NOTREACHED() << L"Received unexpected notification";
   }
@@ skipping 68 matching lines @@
 gfx::Size BrowserActionsContainer::GetPreferredSize() {
   if (browser_action_views_.empty())
     return gfx::Size(0, 0);
   int width = kHorizontalPadding * 2 +
       browser_action_views_.size() * kIconSize;
   return gfx::Size(width, kIconSize);
 }
 
 void BrowserActionsContainer::Layout() {
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
-    views::TextButton* view = browser_action_views_[i];
+    BrowserActionImageView* view = browser_action_views_[i];
     int x = kHorizontalPadding + i * kIconSize;
     view->SetBounds(x, kControlVertOffset, kIconSize,
         height() - (2 * kControlVertOffset));
   }
 }
 
 void BrowserActionsContainer::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   if (type == NotificationType::EXTENSION_LOADED ||
       type == NotificationType::EXTENSION_UNLOADED ||
       type == NotificationType::EXTENSION_UNLOADED_DISABLED) {
     RefreshBrowserActionViews();
   } else {
     NOTREACHED() << L"Received unexpected notification";
   }
 }
 
 void BrowserActionsContainer::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
 
-  // TODO(aa): Hook this up to the API to feed the badge color and text
-  // dynamically.
-  std::string text;
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
-    if (i > 0) {
-      text += IntToString(i);
-      PaintBadge(canvas, browser_action_views_[i],
-                 SkColorSetARGB(255, 218, 0, 24), text);
-    }
+    BrowserActionImageView* view = browser_action_views_[i];
+    const std::string& text = view->browser_action_state()->badge_text();
+    SkColor* color = view->browser_action_state()->badge_background_color();
+
+    if (!text.empty())
+      PaintBadge(canvas, browser_action_views_[i], *color, text);
   }
 }
 
 void BrowserActionsContainer::PaintBadge(gfx::Canvas* canvas, 
-                                         views::TextButton* view,
+                                         BrowserActionImageView* view,
                                          const SkColor& badge_color,
                                          const std::string& text) {
   const int kTextSize = 8;
   const int kBottomMargin = 6;
   const int kPadding = 2;
   const int kBadgeHeight = 11;
   const int kMaxTextWidth = 23;
   const int kCenterAlignThreshold = 20;  // at than width, we center align
 
   canvas->save();
@@ skipping 60 matching lines @@
   // text was too large.
   rect.fLeft += kPadding;
   rect.fRight -= kPadding;
   canvas->clipRect(rect);
   canvas->drawText(text.c_str(), text.size(),
                    rect.fLeft + (rect.width() - text_width) / 2,
                    rect.fTop + kTextSize + 1,
                    text_paint);
   canvas->restore();
 }