Linux: implement Page Actions support.

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
 
 #include "build/build_config.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
-#include "app/gfx/favicon_size.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/file_util.h"
 #include "base/keyboard_codes.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/alternate_nav_url_fetcher.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/page_info_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/navigation_entry.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/info_bubble.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/page_action.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
-#include "skia/ext/image_operations.h"
 #include "views/focus/focus_manager.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
-#include "webkit/glue/image_decoder.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #include "chrome/browser/views/first_run_bubble.h"
 #endif
 
 using views::View;
 
 // static
 const int LocationBarView::kVertMargin = 2;
@@ skipping 593 matching lines @@
 void LocationBarView::DeletePageActionViews() {
   if (!page_action_image_views_.empty()) {
     for (size_t i = 0; i < page_action_image_views_.size(); ++i)
       RemoveChildView(page_action_image_views_[i]);
     STLDeleteContainerPointers(page_action_image_views_.begin(),
                                page_action_image_views_.end());
     page_action_image_views_.clear();
   }
 }
 
-std::vector<PageAction*> LocationBarView::GetPageActions() {
-  std::vector<PageAction*> result;
-  if (!profile_->GetExtensionsService())
-    return result;
-
-  // Query the extension system to see how many page actions we have.
-  // TODO(finnur): Sort the page icons in some meaningful way.
-  const ExtensionList* extensions =
-      profile_->GetExtensionsService()->extensions();
-  for (ExtensionList::const_iterator iter = extensions->begin();
-       iter != extensions->end(); ++iter) {
-    const PageActionMap& page_actions = (*iter)->page_actions();
-    for (PageActionMap::const_iterator i(page_actions.begin());
-         i != page_actions.end(); ++i) {
-      result.push_back(i->second);
-    }
-  }
-
-  return result;
-}
-
 void LocationBarView::RefreshPageActionViews() {
-  std::vector<PageAction*> page_actions = GetPageActions();
+  std::vector<PageAction*> page_actions;
+  if (profile_->GetExtensionsService())
+    page_actions = profile_->GetExtensionsService()->GetPageActions();
 
   // On startup we sometimes haven't loaded any extensions. This makes sure
   // we catch up when the extensions (and any page actions) load.
   if (page_actions.size() != page_action_image_views_.size()) {
     DeletePageActionViews();  // Delete the old views (if any).
 
     page_action_image_views_.resize(page_actions.size());
 
     for (size_t i = 0; i < page_actions.size(); ++i) {
       page_action_image_views_[i] =
@@ skipping 508 matching lines @@
 void LocationBarView::SecurityImageView::ShowInfoBubble() {
   std::wstring text;
   model_->GetIconHoverText(&text);
   ShowInfoBubbleImpl(text, GetColor(
       model_->GetSecurityLevel() == ToolbarModel::SECURE,
       SECURITY_INFO_BUBBLE_TEXT));
 }
 
 // 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, 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, int index) {
-    if (image == NULL) {
-      NOTREACHED() << "Image failed to decode.";
-      image = new SkBitmap();
-    }
-    if (view_)
-      view_->OnImageLoaded(image, index);
-    delete image;
-    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,
-                int index)
-    : callback_loop_(MessageLoop::current()),
-      tracker_(tracker),
-      path_(path),
-      index_(index) {}
-
-  void ReportBack(SkBitmap* image) {
-    DCHECK(image);
-    callback_loop_->PostTask(FROM_HERE, NewRunnableMethod(tracker_,
-        &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;
-    }
-
-    // Decode the image using WebKit's image decoder.
-    const unsigned char* data =
-        reinterpret_cast<const unsigned char*>(file_contents.data());
-    webkit_glue::ImageDecoder decoder(gfx::Size(kFavIconSize, kFavIconSize));
-    scoped_ptr<SkBitmap> decoded(new SkBitmap());
-    *decoded = decoder.Decode(data, file_contents.length());
-    if (decoded->empty()) {
-      ReportBack(NULL);
-      return;  // Unable to decode.
-    }
-
-    if (decoded->width() != kFavIconSize || decoded->height() != kFavIconSize) {
-      // The bitmap is not the correct size, re-sample.
-      int new_width = decoded->width();
-      int new_height = decoded->height();
-      // Calculate what dimensions to use within the constraints (16x16 max).
-      calc_favicon_target_size(&new_width, &new_height);
-      *decoded = skia::ImageOperations::Resize(
-          *decoded, skia::ImageOperations::RESIZE_LANCZOS3,
-          new_width, new_height);
-    }
-
-    ReportBack(decoded.release());
-  }
-
- 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),
       current_tab_id_(-1),
       tooltip_(page_action_->name()) {
   Extension* extension = profile->GetExtensionsService()->GetExtensionById(
       page_action->extension_id());
   DCHECK(extension);
 
   // 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_paths().empty());
   const std::vector<std::string>& 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();
   tracker_ = new ImageLoadingTracker(this, icon_paths.size());
   for (std::vector<std::string>::const_iterator iter = icon_paths.begin();
        iter != icon_paths.end(); ++iter) {
     FilePath path = extension->GetResourcePath(*iter);
-    file_loop->PostTask(FROM_HERE, new LoadImageTask(tracker_, path, index++));
+    tracker_->PostLoadImageTask(path);
   }
 }
 
 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_->extension_id(), page_action_->id(),
       current_tab_id_, current_url_.spec());
   return true;
 }
 
 void LocationBarView::PageActionImageView::ShowInfoBubble() {
   ShowInfoBubbleImpl(ASCIIToWide(tooltip_), GetColor(false, TEXT));
 }
 
+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();
+}
+
 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;
 
   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,
-                                                         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);
   MessageLoop::current()->PostDelayedTask(FROM_HERE, task, 30);
 }
 
@@ skipping 36 matching lines @@
 }
 
 int LocationBarView::PageActionVisibleCount() {
   int result = 0;
   for (size_t i = 0; i < page_action_image_views_.size(); i++) {
     if (page_action_image_views_[i]->IsVisible())
       ++result;
   }
   return result;
 }