[Extensions] Show a "refresh" bubble when needed with click-to-script

chrome/browser/ui/cocoa/extensions/browser_actions_controller.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/extensions/browser_actions_controller.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 149 matching lines @@
 
 // Handles when a menu item within the chevron overflow menu is selected.
 - (void)chevronItemSelected:(id)menuItem;
 
 // Updates the container's grippy cursor based on the number of hidden buttons.
 - (void)updateGrippyCursors;
 
 // Returns the associated ToolbarController.
 - (ToolbarController*)toolbarController;
 
-// Creates a message bubble anchored to the given |anchorAction|, or the app
-// menu if no |anchorAction| is null.
+// Creates a message bubble with the given |delegate| that is anchored to the
+// given |anchorView|.
 - (ToolbarActionsBarBubbleMac*)createMessageBubble:
     (scoped_ptr<ToolbarActionsBarBubbleDelegate>)delegate
-    anchorToSelf:(BOOL)anchorToSelf;
+    anchorView:(NSView*)anchorView;
 
 // Called when the window for the active bubble is closing, and sets the active
 // bubble to nil.
 - (void)bubbleWindowClosing:(NSNotification*)notification;
 
 // Sets the current focused view. Should only be used for the overflow
 // container.
 - (void)setFocusedViewIndex:(NSInteger)index;
 
 @end
@@ skipping 31 matching lines @@
                         int target_width,
                         bool suppress_chevron) override;
   void SetChevronVisibility(bool chevron_visible) override;
   int GetWidth(GetWidthTime get_width_time) const override;
   bool IsAnimating() const override;
   void StopAnimating() override;
   int GetChevronWidth() const override;
   void ShowExtensionMessageBubble(
       scoped_ptr<extensions::ExtensionMessageBubbleController> controller,
       ToolbarActionViewController* anchor_action) override;
+  void ShowToolbarActionBubble(
+      scoped_ptr<ToolbarActionsBarBubbleDelegate> bubble) override;
 
   // The owning BrowserActionsController; weak.
   BrowserActionsController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ToolbarActionsBarBridge);
 };
 
 ToolbarActionsBarBridge::ToolbarActionsBarBridge(
     BrowserActionsController* controller)
     : controller_(controller) {
@@ skipping 54 matching lines @@
       NSWidth([[controller_ containerView] frame])];
 }
 
 int ToolbarActionsBarBridge::GetChevronWidth() const {
   return kChevronWidth;
 }
 
 void ToolbarActionsBarBridge::ShowExtensionMessageBubble(
     scoped_ptr<extensions::ExtensionMessageBubbleController> bubble_controller,
     ToolbarActionViewController* anchor_action) {
+  NSView* anchorView = nil;
+  BOOL anchoredToAction = NO;
+  if (anchor_action) {
+    BrowserActionButton* actionButton =
+        [controller_ buttonForId:anchor_action->GetId()];
+    if (actionButton && [actionButton superview]) {
+      anchorView = actionButton;
+      anchoredToAction = YES;
+    }
+  }
+  if (!anchorView)
+    anchorView = [[controller_ toolbarController] appMenuButton];
+
   // This goop is a by-product of needing to wire together abstract classes,
   // C++/Cocoa bridges, and ExtensionMessageBubbleController's somewhat strange
   // Show() interface. It's ugly, but it's pretty confined, so it's probably
   // okay (but if we ever need to expand, it might need to be reconsidered).
   extensions::ExtensionMessageBubbleController* weak_controller =
       bubble_controller.get();
   scoped_ptr<ExtensionMessageBubbleBridge> bridge(
       new ExtensionMessageBubbleBridge(std::move(bubble_controller),
-                                       anchor_action != nullptr));
+                                       anchoredToAction));
   ToolbarActionsBarBubbleMac* bubble =
       [controller_ createMessageBubble:std::move(bridge)
-                          anchorToSelf:anchor_action != nil];
+                            anchorView:anchorView];
   weak_controller->OnShown();
   [bubble showWindow:nil];
 }
 
+void ToolbarActionsBarBridge::ShowToolbarActionBubble(
+      scoped_ptr<ToolbarActionsBarBubbleDelegate> bubble) {
+  NSView* anchorView = nil;
+  if (!bubble->GetAnchorActionId().empty()) {
+    BrowserActionButton* button =
+        [controller_ buttonForId:bubble->GetAnchorActionId()];
+    anchorView = button && [button superview] ? button :
+        [[controller_ toolbarController] appMenuButton];
+  } else {
+    anchorView = [controller_ containerView];
+  }
+
+  ToolbarActionsBarBubbleMac* bubbleView =
+      [controller_ createMessageBubble:std::move(bubble)
+                            anchorView:anchorView];
+  [bubbleView showWindow:nil];
+}
+
 }  // namespace
 
 @implementation BrowserActionsController
 
 @synthesize containerView = containerView_;
 @synthesize browser = browser_;
 @synthesize isOverflow = isOverflow_;
 @synthesize activeBubble = activeBubble_;
 
 #pragma mark -
@@ skipping 493 matching lines @@
       NOTREACHED();
   }
 }
 
 - (void)containerMouseEntered:(NSNotification*)notification {
   if (!activeBubble_ &&  // only show one bubble at a time
       toolbarActionsBar_->show_icon_surfacing_bubble()) {
     scoped_ptr<ToolbarActionsBarBubbleDelegate> delegate(
         new ExtensionToolbarIconSurfacingBubbleDelegate(browser_->profile()));
     ToolbarActionsBarBubbleMac* bubble =
-        [self createMessageBubble:std::move(delegate) anchorToSelf:YES];
+        [self createMessageBubble:std::move(delegate)
+                       anchorView:containerView_];
     [bubble showWindow:nil];
   }
   [containerView_ setTrackingEnabled:NO];
   [[NSNotificationCenter defaultCenter]
       removeObserver:self
                 name:kBrowserActionsContainerMouseEntered
               object:containerView_];
 }
 
 - (void)actionButtonDragging:(NSNotification*)notification {
@@ skipping 195 matching lines @@
   [[containerView_ window] invalidateCursorRectsForView:containerView_];
 }
 
 - (ToolbarController*)toolbarController {
   return [[BrowserWindowController browserWindowControllerForWindow:
              browser_->window()->GetNativeWindow()] toolbarController];
 }
 
 - (ToolbarActionsBarBubbleMac*)createMessageBubble:
     (scoped_ptr<ToolbarActionsBarBubbleDelegate>)delegate
-    anchorToSelf:(BOOL)anchorToSelf {
+    anchorView:(NSView*)anchorView {
+  DCHECK(anchorView);
   DCHECK_GE([buttons_ count], 0u);
-  NSView* anchorView =
-      anchorToSelf ? containerView_ : [[self toolbarController] appMenuButton];
   NSPoint anchor = [self popupPointForView:anchorView
                                 withBounds:[anchorView bounds]];
 
   anchor = ui::ConvertPointFromWindowToScreen([containerView_ window], anchor);
   activeBubble_ = [[ToolbarActionsBarBubbleMac alloc]
       initWithParentWindow:[containerView_ window]
                anchorPoint:anchor
                   delegate:std::move(delegate)];
   [[NSNotificationCenter defaultCenter]
       addObserver:self
@@ skipping 13 matching lines @@
 }
 
 #pragma mark -
 #pragma mark Testing Methods
 
 - (BrowserActionButton*)buttonWithIndex:(NSUInteger)index {
   return index < [buttons_ count] ? [buttons_ objectAtIndex:index] : nil;
 }
 
 @end