[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 150 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.

[Avi (use Gerrit), 2016/03/23 22:05:24]

This comment made no sense with the previous version of the function
declaration, and it makes just as no sense with this new version.

Can you reword it to be applicable?

[Devlin, 2016/03/23 22:23:08]

Whoops!  Done.

 - (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_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