PageActions can now specify multiple icons and switch between them...

chrome/browser/views/location_bar_view.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/location_bar_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 1122 matching lines @@
 
 // PageActionImageView----------------------------------------------------------
 
 // The views need to load their icons asynchronously but might be deleted before
 // the images have loaded. This class stays alive while the request is in
 // progress (manages its own lifetime) and keeps track of whether the view still
 // cares about the icon loading.
 class LocationBarView::PageActionImageView::ImageLoadingTracker
   : public base::RefCountedThreadSafe<ImageLoadingTracker> {
  public:
-  explicit ImageLoadingTracker(PageActionImageView* view) : view_(view) {
+  explicit ImageLoadingTracker(PageActionImageView* view, int image_count)
+    : view_(view), image_count_(image_count) {
     AddRef();  // We hold on to a reference to ourself to make sure we don't
                // get deleted until we get a response from image loading (see
                // ImageLoadingDone).
   }
   ~ImageLoadingTracker() {}
 
   void StopTrackingImageLoad() {
     view_ = NULL;
   }
 
-  void OnImageLoaded(SkBitmap* image) {
-    view_->OnImageLoaded(image);
+  void OnImageLoaded(SkBitmap* image, int index) {
+    view_->OnImageLoaded(image, index);
     delete image;
-    Release();  // We are no longer needed.
+    if (--image_count_ == 0)
+      Release();  // We are no longer needed.
   }
 
  private:
 
   // The view that is waiting for the image to load.
   PageActionImageView* view_;
+
+  // The number of images this ImageTracker should keep track of.
+  int image_count_;
 };
 
 // The LoadImageTask is for asynchronously loading the image on the file thread.
 // If the image is successfully loaded and decoded it will report back on the
 // |callback_loop| to let the caller know the image is done loading.
 class LocationBarView::PageActionImageView::LoadImageTask : public Task {
  public:
+  // Constructor for the LoadImageTask class. |tracker| is the object that
+  // we use to communicate back to the entity that wants the image after we
+  // decode it. |path| is the path to load the image from. |index| is an
+  // identifier for the image that we pass back to the caller.
   LoadImageTask(ImageLoadingTracker* tracker,
-                const FilePath& path)
+                const FilePath& path,
+                int index)
     : callback_loop_(MessageLoop::current()),
       tracker_(tracker),
-      path_(path) {}
+      path_(path),
+      index_(index) {}
 
   void ReportBack(SkBitmap* image) {
     DCHECK(image);
     callback_loop_->PostTask(FROM_HERE, NewRunnableMethod(tracker_,
-        &PageActionImageView::ImageLoadingTracker::OnImageLoaded, image));
+        &PageActionImageView::ImageLoadingTracker::OnImageLoaded,
+        image,
+        index_));
   }
 
   virtual void Run() {
     // Read the file from disk.
     std::string file_contents;
     if (!file_util::PathExists(path_) ||
         !file_util::ReadFileToString(path_, &file_contents)) {
       ReportBack(NULL);
       return;
     }
@@ skipping 25 matching lines @@
 
  private:
   // The message loop that we need to call back on to report that we are done.
   MessageLoop* callback_loop_;
 
   // The object that is waiting for us to respond back.
   ImageLoadingTracker* tracker_;
 
   // The path to the image to load asynchronously.
   FilePath path_;
+
+  // The index of the icon being loaded.
+  int index_;
 };
 
 LocationBarView::PageActionImageView::PageActionImageView(
     LocationBarView* owner,
     Profile* profile,
     const PageAction* page_action)
     : LocationBarImageView(),
       owner_(owner),
       profile_(profile),
       page_action_(page_action),
-      tracker_(new ImageLoadingTracker(this)) {
+      current_tab_id_(-1),
+      tooltip_(page_action_->name()) {
   // Load the images this view needs asynchronously on the file thread. We'll
   // get a call back into OnImageLoaded if the image loads successfully. If not,
   // the ImageView will have no image and will not appear in the Omnibox.
-  DCHECK(!page_action->icon_path().empty());
-  FilePath path = FilePath(page_action->icon_path());
+  DCHECK(!page_action->icon_paths().empty());
+  const std::vector<FilePath>& icon_paths = page_action->icon_paths();
+  page_action_icons_.resize(icon_paths.size());
+  int index = 0;
   MessageLoop* file_loop = g_browser_process->file_thread()->message_loop();
-  file_loop->PostTask(FROM_HERE,
-      new LoadImageTask(tracker_, page_action->icon_path()));
+  tracker_ = new ImageLoadingTracker(this, icon_paths.size());
+  for (std::vector<FilePath>::const_iterator iter = icon_paths.begin();
+       iter != icon_paths.end(); ++iter) {
+    FilePath path = *iter;
+    file_loop->PostTask(FROM_HERE, new LoadImageTask(tracker_, path, index++));
+  }
 }
 
 LocationBarView::PageActionImageView::~PageActionImageView() {
   if (tracker_)
     tracker_->StopTrackingImageLoad();
 }
 
 bool LocationBarView::PageActionImageView::OnMousePressed(
     const views::MouseEvent& event) {
   // Our PageAction icon was clicked on, notify proper authorities.
   ExtensionBrowserEventRouter::GetInstance()->PageActionExecuted(
       profile_, page_action_->id(), current_tab_id_, current_url_.spec());
   return true;
 }
 
 void LocationBarView::PageActionImageView::ShowInfoBubble() {
   SkColor text_color = SK_ColorBLACK;
-  ShowInfoBubbleImpl(ASCIIToWide(page_action_->name()), text_color);
+  ShowInfoBubbleImpl(ASCIIToWide(tooltip_), text_color);
 }
 
 void LocationBarView::PageActionImageView::UpdateVisibility(
     TabContents* contents, GURL url) {
   // Save this off so we can pass it back to the extension when the action gets
   // executed. See PageActionImageView::OnMousePressed.
   current_tab_id_ = ExtensionTabUtil::GetTabId(contents);
   current_url_ = url;
 
-  SetVisible(contents->IsPageActionEnabled(page_action_));
+  const PageActionState* state = contents->GetPageActionState(page_action_);
+  bool visible = state != NULL;
+  if (visible) {
+    // Set the tooltip.
+    if (state->title().empty())
+      tooltip_ = page_action_->name();
+    else
+      tooltip_ = state->title();
+    // Set the image.
+    int index = state->icon_index();
+    // The image index (if not within bounds) will be set to the first image.
+    if (index < 0 || index >= static_cast<int>(page_action_icons_.size()))
+      index = 0;
+    ImageView::SetImage(page_action_icons_[index]);
+  }
+  SetVisible(visible);
 }
 
-void LocationBarView::PageActionImageView::OnImageLoaded(SkBitmap* image) {
-  tracker_ = NULL;  // The tracker object will delete itself when we return.
-  ImageView::SetImage(image);
+void LocationBarView::PageActionImageView::OnImageLoaded(SkBitmap* image,
+                                                         size_t index) {
+  DCHECK(index < page_action_icons_.size());
+  if (index == page_action_icons_.size() - 1)
+    tracker_ = NULL;  // The tracker object will delete itself when we return.
+  page_action_icons_[index] = *image;
   owner_->UpdatePageActions();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, LocationBar implementation:
 
 void LocationBarView::ShowFirstRunBubble(bool use_OEM_bubble) {
   // We wait 30 milliseconds to open. It allows less flicker.
   Task* task = first_run_bubble_.NewRunnableMethod(
       &LocationBarView::ShowFirstRunBubbleInternal, use_OEM_bubble);
@@ skipping 30 matching lines @@
   location_entry_->SetForcedQuery();
 }
 
 void LocationBarView::SaveStateToContents(TabContents* contents) {
   location_entry_->SaveStateToTab(contents);
 }
 
 void LocationBarView::Revert() {
   location_entry_->RevertAll();
 }