Allow slightly larger browser and page action icons.

chrome/browser/views/browser_actions_container.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/browser_actions_container.h"
 
 #include "app/gfx/canvas.h"
 #include "app/resource_bundle.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/image_loading_tracker.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/extensions/extension_popup.h"
 #include "chrome/browser/views/toolbar_view.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "grit/app_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/button/text_button.h"
 
-// The size of the icon for page actions.
-static const int kIconSize = 29;
+// The size (both dimensions) of the buttons for page actions.
+static const int kButtonSize = 29;
 
 // The padding between the browser actions and the omnibox/page menu.
 static const int kHorizontalPadding = 4;
 
 // This is the same value from toolbar.cc. We position the browser actions
 // container flush with the edges of the toolbar as a special case so that we
 // can draw the badge outside the visual bounds of the container.
 static const int kControlVertOffset = 6;
 
 // The maximum of the minimum number of browser actions present when there is
@@ skipping 91 matching lines @@
 
   // 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 browser chrome.
   if (!browser_action->icon_paths().empty()) {
     const std::vector<std::string>& icon_paths = browser_action->icon_paths();
     browser_action_icons_.resize(icon_paths.size());
     tracker_ = new ImageLoadingTracker(this, icon_paths.size());
     for (std::vector<std::string>::const_iterator iter = icon_paths.begin();
          iter != icon_paths.end(); ++iter) {
-      tracker_->PostLoadImageTask(extension->GetResource(*iter));
+      tracker_->PostLoadImageTask(
+          extension->GetResource(*iter),
+          gfx::Size(Extension::kBrowserActionIconMaxSize,
+                    Extension::kBrowserActionIconMaxSize));
     }
   }
 
   registrar_.Add(this, NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
                  Source<ExtensionAction>(browser_action_));
 }
 
 BrowserActionButton::~BrowserActionButton() {
   if (tracker_) {
     tracker_->StopTrackingImageLoad();
@@ skipping 129 matching lines @@
 };
 
 BrowserActionView::BrowserActionView(ExtensionAction* browser_action,
                                      Extension* extension,
                                      BrowserActionsContainer* panel) {
   button_ = new BrowserActionButton(browser_action, extension, panel);
   AddChildView(button_);
 }
 
 void BrowserActionView::Layout() {
-  button_->SetBounds(0, kControlVertOffset, width(),
-                     height() - 2 * kControlVertOffset);
+  button_->SetBounds(0, kControlVertOffset, width(), kButtonSize);
 }
 
 void BrowserActionView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
 
   const std::string& text = button_->browser_action_state()->badge_text();
   if (text.empty())
     return;
 
   const int kTextSize = 8;
@@ skipping 184 matching lines @@
 
   // Otherwise, we send the action to the extension.
   ExtensionBrowserEventRouter::GetInstance()->BrowserActionExecuted(
       profile_, browser_action.extension_id(), toolbar_->browser());
 }
 
 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);
+      browser_action_views_.size() * kButtonSize;
+  return gfx::Size(width, kButtonSize);
 }
 
 void BrowserActionsContainer::Layout() {
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
     BrowserActionView* view = browser_action_views_[i];
-    int x = kHorizontalPadding + i * kIconSize;
-    if (x + kIconSize <= width()) {
-      view->SetBounds(x, 0, kIconSize, height());
+    int x = kHorizontalPadding + i * kButtonSize;
+    if (x + kButtonSize <= width()) {
+      view->SetBounds(x, 0, kButtonSize, height());
       view->SetVisible(true);
     } else {
       view->SetVisible(false);
     }
   }
 }
 
 void BrowserActionsContainer::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
@@ skipping 29 matching lines @@
       task_factory_.NewRunnableMethod(&BrowserActionsContainer::HidePopup));
 }
 
 int BrowserActionsContainer::GetClippedPreferredWidth(int available_width) {
   if (browser_action_views_.size() == 0)
     return 0;
 
   // We have at least one browser action. Make some of them sticky.
   int min_width = kHorizontalPadding * 2 +
       std::min(static_cast<int>(browser_action_views_.size()),
-               kMinimumNumberOfVisibleBrowserActions) * kIconSize;
+               kMinimumNumberOfVisibleBrowserActions) * kButtonSize;
 
   // Even if available_width is <= 0, we still return at least the |min_width|.
   if (available_width <= 0)
     return min_width;
 
-  return std::max(min_width, available_width - available_width % kIconSize +
+  return std::max(min_width, available_width - available_width % kButtonSize +
                   kHorizontalPadding * 2);
 }