Move page actions over to ExtensionAction2

chrome/browser/gtk/location_bar_view_gtk.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/gtk/location_bar_view_gtk.h"
 
 #include <string>
 
 #include "app/gfx/canvas_paint.h"
 #include "app/gfx/gtk_util.h"
@@ skipping 15 matching lines @@
 #include "chrome/browser/gtk/rounded_window.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/page_transition_types.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
-#include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/window_open_disposition.h"
 
 namespace {
 
 // We are positioned with a little bit of extra space that we don't use now.
 const int kTopMargin = 1;
 const int kBottomMargin = 1;
 const int kLeftMargin = 1;
 const int kRightMargin = 1;
 // We draw a border on the top and bottom (but not on left or right).
@@ skipping 352 matching lines @@
   location_entry_->SetFocus();
   location_entry_->SelectAll(true);
 }
 
 void LocationBarViewGtk::FocusSearch() {
   location_entry_->SetFocus();
   location_entry_->SetForcedQuery();
 }
 
 void LocationBarViewGtk::UpdatePageActions() {
-  std::vector<ExtensionAction*> page_actions;
-  if (profile_->GetExtensionsService())
-      page_actions = profile_->GetExtensionsService()->GetPageActions();
+  std::vector<ExtensionAction2*> page_actions;
+  ExtensionsService* service = profile_->GetExtensionsService();
+  if (!service)
+    return;
 
-  // Page actions can be created without an icon, so make sure we count only
-  // those that have been given an icon.
-  for (size_t i = 0; i < page_actions.size();) {
-    if (page_actions[i]->icon_paths().empty())
-      page_actions.erase(page_actions.begin() + i);
-    else
-      ++i;
+  // Find all the page actions.
+  for (size_t i = 0; i < service->extensions()->size(); ++i) {
+    if (service->extensions()->at(i)->page_action())
+      page_actions.push_back(service->extensions()->at(i)->page_action());
   }
 
   // Initialize on the first call, or re-inialize if more extensions have been
   // loaded or added after startup.
   if (page_actions.size() != page_action_views_.size()) {
     page_action_views_.reset();  // Delete the old views (if any).
 
     for (size_t i = 0; i < page_actions.size(); ++i) {
       page_action_views_.push_back(
           new PageActionViewGtk(this, profile_, page_actions[i]));
@@ skipping 253 matching lines @@
   }
   tab->ShowPageInfo(nav_entry->url(), nav_entry->ssl(), true);
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk::PageActionViewGtk
 
 LocationBarViewGtk::PageActionViewGtk::PageActionViewGtk(
     LocationBarViewGtk* owner, Profile* profile,
-    const ExtensionAction* page_action)
+    ExtensionAction2* page_action)
     : owner_(owner),
       profile_(profile),
       page_action_(page_action),
-      last_icon_skbitmap_(NULL),
       last_icon_pixbuf_(NULL) {
   event_box_.Own(gtk_event_box_new());
   gtk_widget_set_size_request(event_box_.get(), kButtonSize, kButtonSize);
 
   // Make the event box not visible so it does not paint a background.
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
   g_signal_connect(event_box_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressed), this);
   g_signal_connect_after(event_box_.get(), "expose-event",
                          G_CALLBACK(OnExposeEvent), this);
 
   image_.Own(gtk_image_new());
   gtk_container_add(GTK_CONTAINER(event_box_.get()), image_.get());
 
   Extension* extension = profile->GetExtensionsService()->GetExtensionById(
       page_action->extension_id());
   DCHECK(extension);
 
-  DCHECK(!page_action->icon_paths().empty());
-  const std::vector<std::string>& icon_paths = page_action->icon_paths();
-  pixbufs_.resize(icon_paths.size());
+  // Load all the icons declared in the manifest. This is the contents of the
+  // icons array, plus the default_icon property, if any.
+  std::vector<std::string> icon_paths(*page_action->icon_paths());
+  if (!page_action_->default_icon_path().empty())
+    icon_paths.push_back(page_action_->default_icon_path());
+
   tracker_ = new ImageLoadingTracker(this, icon_paths.size());
-  for (std::vector<std::string>::const_iterator iter = icon_paths.begin();
+  for (std::vector<std::string>::iterator iter = icon_paths.begin();
        iter != icon_paths.end(); ++iter) {
     tracker_->PostLoadImageTask(
         extension->GetResource(*iter),
         gfx::Size(Extension::kPageActionIconMaxSize,
                   Extension::kPageActionIconMaxSize));
   }
 }
 
 LocationBarViewGtk::PageActionViewGtk::~PageActionViewGtk() {
   if (tracker_)
     tracker_->StopTrackingImageLoad();
   image_.Destroy();
   event_box_.Destroy();
-  for (size_t i = 0; i < pixbufs_.size(); ++i) {
-    if (pixbufs_[i])
-      g_object_unref(pixbufs_[i]);
+  for (PixbufMap::iterator iter = pixbufs_.begin(); iter != pixbufs_.end();
+       ++iter) {
+    g_object_unref(iter->second);
   }
   if (last_icon_pixbuf_)
     g_object_unref(last_icon_pixbuf_);
 }
 
 void LocationBarViewGtk::PageActionViewGtk::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;
 
-  const ExtensionActionState* state =
-      contents->GetPageActionState(page_action_);
-  bool visible = state && !state->hidden();
+  bool visible = page_action_->GetIsVisible(current_tab_id_);
   if (visible) {
     // Set the tooltip.
-    if (state->title().empty())
-      gtk_widget_set_tooltip_text(event_box_.get(),
-                                  page_action_->title().c_str());
-    else
-      gtk_widget_set_tooltip_text(event_box_.get(), state->title().c_str());
+    gtk_widget_set_tooltip_text(event_box_.get(),
+                                page_action_->GetTitle(current_tab_id_).c_str());
 
     // Set the image.
-    SkBitmap* icon = state->icon();
+    // It can come from three places. In descending order of priority:
+    // - The developer can set it dynamically by path or bitmap. It will be in
+    //   page_action_->GetIcon().
+    // - The developer can set it dyanmically by index. It will be in
+    //   page_action_->GetIconIndex().
+    // - It can be set in the manifest by path. It will be in page_action_->
+    //   default_icon_path().
+
+    // First look for a dynamically set bitmap.
+    SkBitmap icon = page_action_->GetIcon(current_tab_id_);
     GdkPixbuf* pixbuf = NULL;
-    if (icon) {
-      if (icon != last_icon_skbitmap_) {
+    if (!icon.isNull()) {
+      if (icon.pixelRef() != last_icon_skbitmap_.pixelRef()) {
         if (last_icon_pixbuf_)
           g_object_unref(last_icon_pixbuf_);
         last_icon_skbitmap_ = icon;
-        last_icon_pixbuf_ = gfx::GdkPixbufFromSkBitmap(icon);
+        last_icon_pixbuf_ = gfx::GdkPixbufFromSkBitmap(&icon);
       }
       DCHECK(last_icon_pixbuf_);
       pixbuf = last_icon_pixbuf_;
     } else {
-      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>(pixbufs_.size()))
-        index = 0;
-      pixbuf = pixbufs_[index];
+      // Otherwise look for a dynamically set index, or fall back to the
+      // default path.
+      int icon_index = page_action_->GetIconIndex(current_tab_id_);
+      std::string icon_path;
+      if (icon_index >= 0)
+        icon_path = page_action_->icon_paths()->at(icon_index);
+      else
+        icon_path = page_action_->default_icon_path();
+
+      if (!icon_path.empty()) {
+        PixbufMap::iterator iter = pixbufs_.find(icon_path);
+        if (iter != pixbufs_.end())
+          pixbuf = iter->second;
+      }
     }
 
     // The pixbuf might not be loaded yet.
     if (pixbuf)
       gtk_image_set_from_pixbuf(GTK_IMAGE(image_.get()), pixbuf);
     else
       visible = false;
   }
 
   if (visible) {
     gtk_widget_show_all(event_box_.get());
   } else {
     gtk_widget_hide_all(event_box_.get());
   }
 }
 
 void LocationBarViewGtk::PageActionViewGtk::OnImageLoaded(SkBitmap* image,
                                                           size_t index) {
-  DCHECK(index < pixbufs_.size());
-  if (index == pixbufs_.size() - 1)
-    tracker_ = NULL;  // The tracker object will delete itself when we return.
-  pixbufs_[index] = gfx::GdkPixbufFromSkBitmap(image);
+  // We loaded icons()->size() icons, plus one extra if the page action had
+  // a default icon.
+  size_t total_icons = page_action_->icon_paths()->size();
+  if (!page_action_->default_icon_path().empty())
+    total_icons++;
+  DCHECK(index < total_icons);
+
+  // Map the index of the loaded image back to its name. If we ever get an
+  // index greater than the number of icons, it must be the default icon.
+  if (image) {
+    GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(image);
+    if (index < page_action_->icon_paths()->size())
+      pixbufs_[page_action_->icon_paths()->at(index)] = pixbuf;
+    else
+      pixbufs_[page_action_->default_icon_path()] = pixbuf;
+  }
+
+  // If we are done, release the tracker.
+  if (index == (total_icons - 1))
+    tracker_ = NULL;
+
   owner_->UpdatePageActions();
 }
 
 // static
 gboolean LocationBarViewGtk::PageActionViewGtk::OnButtonPressed(
     GtkWidget* sender,
     GdkEventButton* event,
     LocationBarViewGtk::PageActionViewGtk* page_action_view) {
   ExtensionBrowserEventRouter::GetInstance()->PageActionExecuted(
       page_action_view->profile_,
       page_action_view->page_action_->extension_id(),
       page_action_view->page_action_->id(),
       page_action_view->current_tab_id_,
       page_action_view->current_url_.spec(),
       event->button);
   return true;
 }
 
 // static
 gboolean LocationBarViewGtk::PageActionViewGtk::OnExposeEvent(
     GtkWidget* widget, GdkEventExpose* event, PageActionViewGtk* view) {
   TabContents* contents = view->owner_->browser_->GetSelectedTabContents();
   if (!contents)
     return FALSE;
-  const ExtensionActionState* state =
-      contents->GetPageActionState(view->page_action_);
-  if (!state || state->badge_text().empty())
+
+  int tab_id = ExtensionTabUtil::GetTabId(contents);
+  if (tab_id < 0)
+    return FALSE;
+
+  std::string badge_text = view->page_action_->GetBadgeText(tab_id);
+  if (badge_text.empty())
     return FALSE;
 
   gfx::CanvasPaint canvas(event, false);
   gfx::Rect bounding_rect(widget->allocation);
-  ExtensionActionState::PaintBadge(&canvas, bounding_rect,
-                                   state->badge_text(),
-                                   state->badge_text_color(),
-                                   state->badge_background_color());
+  view->page_action_->PaintBadge(&canvas, bounding_rect, tab_id);
   return FALSE;
 }