Zoom Extension API (chrome)

chrome/browser/ui/views/location_bar/zoom_bubble_view.cc

 // Copyright (c) 2012 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/ui/views/location_bar/zoom_bubble_view.h"
 
 #include "base/i18n/rtl.h"
+#include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chrome_page_zoom.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/browser/ui/views/location_bar/zoom_view.h"
 #include "chrome/browser/ui/zoom/zoom_controller.h"
+#include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "content/public/browser/notification_source.h"
+#include "extensions/common/manifest_handlers/icons_handler.h"
 #include "grit/generated_resources.h"
+#include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/favicon_size.h"
+#include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/separator.h"
-#include "ui/views/layout/box_layout.h"
+#include "ui/views/layout/grid_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // The number of milliseconds the bubble should stay on the screen if it will
 // close automatically.
 const int kBubbleCloseDelay = 1500;
 
 // The bubble's padding from the screen edge, used in fullscreen.
@@ skipping 10 matching lines @@
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   DCHECK(browser && browser->window() && browser->fullscreen_controller());
 
   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser);
   bool is_fullscreen = browser_view->IsFullscreen();
   bool anchor_to_view = !is_fullscreen ||
       browser_view->immersive_mode_controller()->IsRevealed();
   views::View* anchor_view = anchor_to_view ?
       browser_view->GetLocationBarView()->zoom_view() : NULL;
 
-  // If the bubble is already showing in this window and its |auto_close_| value
-  // is equal to |auto_close|, the bubble can be reused and only the label text
-  // needs to be updated.
+  // Find the extension that initiated the zoom change, if any.
+  ZoomController* zoom_controller =
+      ZoomController::FromWebContents(web_contents);
+  const extensions::Extension* extension = zoom_controller->last_extension();
+
+  // If the bubble is already showing in this window, its |auto_close_| value
+  // is equal to |auto_close|, and the zoom change was not initiated by an
+  // extension, then the bubble can be reused and only the label text needs to
+  // be updated.
   if (zoom_bubble_ &&
       zoom_bubble_->GetAnchorView() == anchor_view &&
-      zoom_bubble_->auto_close_ == auto_close) {
+      zoom_bubble_->auto_close_ == auto_close &&
+      !extension) {
     zoom_bubble_->Refresh();
-  } else {
-    // If the bubble is already showing but its |auto_close_| value is not equal
-    // to |auto_close|, the bubble's focus properties must change, so the
-    // current bubble must be closed and a new one created.
-    CloseBubble();
+    return;
+  }
 
-    zoom_bubble_ = new ZoomBubbleView(anchor_view,
-                                      web_contents,
-                                      auto_close,
-                                      browser_view->immersive_mode_controller(),
-                                      browser->fullscreen_controller());
+  // If the bubble is already showing but its |auto_close_| value is not equal
+  // to |auto_close|, the bubble's focus properties must change, so the
+  // current bubble must be closed and a new one created.
+  CloseBubble();
 
-    // If we do not have an anchor view, parent the bubble to the content area.
-    if (!anchor_to_view) {
-      zoom_bubble_->set_parent_window(web_contents->GetTopLevelNativeWindow());
-    }
+  zoom_bubble_ = new ZoomBubbleView(anchor_view,
+                                    web_contents,
+                                    auto_close,
+                                    browser_view->immersive_mode_controller(),
+                                    browser->fullscreen_controller());
 
-    views::BubbleDelegateView::CreateBubble(zoom_bubble_);
+  // If the zoom change was initiated by an extension, capture the relevent
+  // information from it.
+  if (extension)
+    zoom_bubble_->SetExtensionInfo(extension);
 
-    // Adjust for fullscreen after creation as it relies on the content size.
-    if (is_fullscreen)
-      zoom_bubble_->AdjustForFullscreen(browser_view->GetBoundsInScreen());
+  // If we do not have an anchor view, parent the bubble to the content area.
+  if (!anchor_to_view)
+    zoom_bubble_->set_parent_window(web_contents->GetTopLevelNativeWindow());
 
-    if (zoom_bubble_->use_focusless())
-      zoom_bubble_->GetWidget()->ShowInactive();
-    else
-      zoom_bubble_->GetWidget()->Show();
-  }
+  views::BubbleDelegateView::CreateBubble(zoom_bubble_);
+
+  // Adjust for fullscreen after creation as it relies on the content size.
+  if (is_fullscreen)
+    zoom_bubble_->AdjustForFullscreen(browser_view->GetBoundsInScreen());
+
+  if (zoom_bubble_->use_focusless())
+    zoom_bubble_->GetWidget()->ShowInactive();
+  else
+    zoom_bubble_->GetWidget()->Show();
 }
 
 // static
 void ZoomBubbleView::CloseBubble() {
   if (zoom_bubble_)
     zoom_bubble_->Close();
 }
 
 // static
 bool ZoomBubbleView::IsShowing() {
   // The bubble may be in the process of closing.
   return zoom_bubble_ != NULL && zoom_bubble_->GetWidget()->IsVisible();
 }
 
 // static
 const ZoomBubbleView* ZoomBubbleView::GetZoomBubbleForTest() {
   return zoom_bubble_;
 }
 
 ZoomBubbleView::ZoomBubbleView(
     views::View* anchor_view,
     content::WebContents* web_contents,
     bool auto_close,
     ImmersiveModeController* immersive_mode_controller,
     FullscreenController* fullscreen_controller)
     : BubbleDelegateView(anchor_view, anchor_view ?
           views::BubbleBorder::TOP_RIGHT : views::BubbleBorder::NONE),
+      image_button_(NULL),
       label_(NULL),
       web_contents_(web_contents),
       auto_close_(auto_close),
       immersive_mode_controller_(immersive_mode_controller) {
   // Compensate for built-in vertical padding in the anchor view's image.
   set_anchor_view_insets(gfx::Insets(5, 0, 5, 0));
   set_use_focusless(auto_close);
   set_notify_enter_exit_on_child(true);
 
   // Add observers to close the bubble if the fullscreen state or immersive
@@ skipping 17 matching lines @@
   const size_t bubble_half_width = width() / 2;
   const int x_pos = base::i18n::IsRTL() ?
       screen_bounds.x() + bubble_half_width + kFullscreenPaddingEnd :
       screen_bounds.right() - bubble_half_width - kFullscreenPaddingEnd;
   SetAnchorRect(gfx::Rect(x_pos, screen_bounds.y(), 0, 0));
 }
 
 void ZoomBubbleView::Refresh() {
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(web_contents_);
-  int zoom_percent = zoom_controller->zoom_percent();
+  int zoom_percent = zoom_controller->GetZoomPercent();
   label_->SetText(
       l10n_util::GetStringFUTF16Int(IDS_TOOLTIP_ZOOM, zoom_percent));
   StartTimerIfNecessary();
 }
 
 void ZoomBubbleView::Close() {
   GetWidget()->Close();
 }
 
+void ZoomBubbleView::SetExtensionInfo(const extensions::Extension* extension) {
+  DCHECK(extension);
+  extension_info_.id = extension->id();
+  extension_info_.name = extension->name();
+
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  const gfx::ImageSkia& default_extension_icon_image =
+      *rb.GetImageSkiaNamed(IDR_EXTENSIONS_FAVICON);
+  int icon_size = gfx::kFaviconSize;
+
+  // We give first preference to an icon from the extension's icon set that
+  // matches the size of the default. But not all extensions will declare an
+  // icon set, or may not have an icon of the default size (we don't want the
+  // bubble to display, for example, a very large icon). In that case, if there
+  // is a browser-action icon (size-19) this is an acceptable alternative.
+  const ExtensionIconSet& icons = extensions::IconsInfo::GetIcons(extension);
+  bool has_default_sized_icon =
+      !icons.Get(gfx::kFaviconSize, ExtensionIconSet::MATCH_EXACTLY).empty();
+  if (has_default_sized_icon) {
+    extension_info_.icon_image.reset(
+        new extensions::IconImage(web_contents_->GetBrowserContext(),
+                                  extension,
+                                  icons,
+                                  icon_size,
+                                  default_extension_icon_image,
+                                  this));
+    return;
+  }
+
+  const extensions::ActionInfo* browser_action =
+      extensions::ActionInfo::GetBrowserActionInfo(extension);
+  if (!browser_action || browser_action->default_icon.empty())
+    return;
+
+  icon_size = browser_action->default_icon.map().begin()->first;
+  extension_info_.icon_image.reset(
+      new extensions::IconImage(web_contents_->GetBrowserContext(),
+                                extension,
+                                browser_action->default_icon,
+                                icon_size,
+                                default_extension_icon_image,
+                                this));
+}
+
 void ZoomBubbleView::StartTimerIfNecessary() {
   if (auto_close_) {
     if (timer_.IsRunning()) {
       timer_.Reset();
     } else {
       timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kBubbleCloseDelay),
           this,
           &ZoomBubbleView::Close);
     }
   }
 }
 
 void ZoomBubbleView::StopTimer() {
   timer_.Stop();
 }
 
+void ZoomBubbleView::OnExtensionIconImageChanged(extensions::IconImage* image) {
+  DCHECK_EQ(image, extension_info_.icon_image.get()) <<
+      "Unknown ImageIcon update.";
+  image_button_->SetPreferredSize(

[sky, 2014/06/25 21:02:42]

Now I'm slightly confused. As long as the image here is the same size as that
from Init, this isn't needed nor is 314. You only need to set the preferred size
initially if you have no image and then later get the image. That doesn't seem
to be the case though. Sorry for the run around.

[wjmaclean, 2014/06/25 21:12:19]

By the time SetImage() is called, we do have a definite icon image in mind;
specifically its size *is* know at this point.

I'll remove these.

+      extension_info_.icon_image->image_skia().size());
+  image_button_->SetImage(views::Button::STATE_NORMAL,
+                          &extension_info_.icon_image->image_skia());
+  image_button_->SchedulePaint();
+}
+
 void ZoomBubbleView::OnMouseEntered(const ui::MouseEvent& event) {
   set_use_focusless(false);
   StopTimer();
 }
 
 void ZoomBubbleView::OnMouseExited(const ui::MouseEvent& event) {
   set_use_focusless(auto_close_);
   StartTimerIfNecessary();
 }
 
 void ZoomBubbleView::OnGestureEvent(ui::GestureEvent* event) {
   if (!zoom_bubble_ || !zoom_bubble_->auto_close_ ||
       event->type() != ui::ET_GESTURE_TAP) {
     return;
   }
 
   // If an auto-closing bubble was tapped, show a non-auto-closing bubble in
   // its place.
   ShowBubble(zoom_bubble_->web_contents_, false);
   event->SetHandled();
 }
 
 void ZoomBubbleView::ButtonPressed(views::Button* sender,
                                    const ui::Event& event) {
-  chrome_page_zoom::Zoom(web_contents_, content::PAGE_ZOOM_RESET);
+  if (sender == image_button_) {
+    DCHECK(extension_info_.icon_image.get()) << "Invalid button press.";
+    Browser* browser = chrome::FindBrowserWithWebContents(web_contents_);
+    chrome::AddSelectedTabWithURL(
+        browser,
+        GURL(base::StringPrintf("chrome://extensions?id=%s",
+                                extension_info_.id.c_str())),
+        content::PAGE_TRANSITION_FROM_API);
+  } else {
+    chrome_page_zoom::Zoom(web_contents_, content::PAGE_ZOOM_RESET);
+  }
 }
 
 void ZoomBubbleView::Init() {
-  SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical,
-      0, 0, views::kRelatedControlVerticalSpacing));
+  // Set up the layout of the zoom bubble. A grid layout is used because
+  // sometimes an extension icon is shown next to the zoom label.
+  views::GridLayout* grid_layout = new views::GridLayout(this);
+  SetLayoutManager(grid_layout);
+  views::ColumnSet* columns = grid_layout->AddColumnSet(0);
+  // First row.
+  if (extension_info_.icon_image.get()) {
+    columns->AddColumn(views::GridLayout::CENTER,views::GridLayout::CENTER, 2,
+                       views::GridLayout::USE_PREF, 0, 0);
+  }
+  columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
+                     views::GridLayout::USE_PREF, 0, 0);
+  grid_layout->StartRow(0, 0);
 
+  // If this zoom change was initiated by an extension, that extension will be
+  // attributed by showing its icon in the zoom bubble.
+  if (extension_info_.icon_image.get()) {
+    image_button_ = new views::ImageButton(this);
+    image_button_->SetTooltipText(l10n_util::GetStringFUTF16(
+        IDS_TOOLTIP_ZOOM_EXTENSION_ICON,
+        base::UTF8ToUTF16(extension_info_.name)));
+    image_button_->SetPreferredSize(
+        extension_info_.icon_image->image_skia().size());
+    image_button_->SetImage(views::Button::STATE_NORMAL,
+                            &extension_info_.icon_image->image_skia());
+    grid_layout->AddView(image_button_);
+  }
+
+  // Add zoom label with the new zoom percent.
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(web_contents_);
-  int zoom_percent = zoom_controller->zoom_percent();
+  int zoom_percent = zoom_controller->GetZoomPercent();
   label_ = new views::Label(
       l10n_util::GetStringFUTF16Int(IDS_TOOLTIP_ZOOM, zoom_percent));
   label_->SetFontList(
       ui::ResourceBundle::GetSharedInstance().GetFontList(
           ui::ResourceBundle::MediumFont));
-  AddChildView(label_);
+  grid_layout->AddView(label_);
 
+  // Second row.
+  grid_layout->AddPaddingRow(0, 8);
+  columns = grid_layout->AddColumnSet(1);
+  columns->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
+                     views::GridLayout::USE_PREF, 0, 0);
+  grid_layout->StartRow(0, 1);
+
+  // Add "Reset to Default" button.
   views::LabelButton* set_default_button = new views::LabelButton(
       this, l10n_util::GetStringUTF16(IDS_ZOOM_SET_DEFAULT));
   set_default_button->SetStyle(views::Button::STYLE_BUTTON);
   set_default_button->SetHorizontalAlignment(gfx::ALIGN_CENTER);
-  AddChildView(set_default_button);
+  grid_layout->AddView(set_default_button);
 
   StartTimerIfNecessary();
 }
 
 void ZoomBubbleView::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_FULLSCREEN_CHANGED);
   CloseBubble();
 }
 
 void ZoomBubbleView::OnImmersiveRevealStarted() {
   CloseBubble();
 }
 
 void ZoomBubbleView::OnImmersiveModeControllerDestroyed() {
   immersive_mode_controller_ = NULL;
 }
 
 void ZoomBubbleView::WindowClosing() {
   // |zoom_bubble_| can be a new bubble by this point (as Close(); doesn't
   // call this right away). Only set to NULL when it's this bubble.
   if (zoom_bubble_ == this)
     zoom_bubble_ = NULL;
 }
+
+ZoomBubbleView::ZoomBubbleExtensionInfo::ZoomBubbleExtensionInfo() {}
+
+ZoomBubbleView::ZoomBubbleExtensionInfo::~ZoomBubbleExtensionInfo() {}