Make a platform-independent ToolbarActionViewController

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 <cmath>
 #include <string>
 
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #import "chrome/browser/ui/cocoa/extensions/browser_action_button.h"
 #import "chrome/browser/ui/cocoa/extensions/browser_actions_container_view.h"
+#import "chrome/browser/ui/cocoa/extensions/extension_action_context_menu_controller.h"
 #import "chrome/browser/ui/cocoa/extensions/extension_popup_controller.h"
 #import "chrome/browser/ui/cocoa/image_button_cell.h"
 #import "chrome/browser/ui/cocoa/menu_button.h"
+#include "chrome/browser/ui/extensions/extension_action_view_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
-#include "extensions/browser/extension_registry.h"
 #include "grit/theme_resources.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSAnimation+Duration.h"
 
 using extensions::Extension;
 using extensions::ExtensionList;
 
 NSString* const kBrowserActionVisibilityChangedNotification =
     @"BrowserActionVisibilityChangedNotification";
 
 namespace {
@@ skipping 42 matching lines @@
 // Useful in the case of a Browser Action being added/removed from the middle of
 // the container, this method repositions each button according to the current
 // toolbar model.
 - (void)positionActionButtonsAndAnimate:(BOOL)animate;
 
 // During container resizing, buttons become more transparent as they are pushed
 // off the screen. This method updates each button's opacity determined by the
 // position of the button.
 - (void)updateButtonOpacity;
 
-// Returns the existing button with the given extension backing it; nil if it
-// cannot be found or the extension's ID is invalid.
-- (BrowserActionButton*)buttonForExtension:(const Extension*)extension;
+// Returns the existing button associated with the given id; nil if it cannot be
+// found.
+- (BrowserActionButton*)buttonForId:(const std::string&)id;
 
 // Returns the preferred width of the container given the number of visible
 // buttons |buttonCount|.
 - (CGFloat)containerWidthWithButtonCount:(NSUInteger)buttonCount;
 
 // Returns the number of buttons that can fit in the container according to its
 // current size.
 - (NSUInteger)containerButtonCapacity;
 
 // Notification handlers for events registered by the class.
@@ skipping 53 matching lines @@
 // Shows or hides the chevron, animating as specified by |animate|.
 - (void)setChevronHidden:(BOOL)hidden
                  inFrame:(NSRect)frame
                  animate:(BOOL)animate;
 
 // 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 ID of the currently selected tab or -1 if none exists.
-- (int)currentTabId;
 @end
 
 // A helper class to proxy extension notifications to the view controller's
 // appropriate methods.
 class ExtensionServiceObserverBridge
     : public content::NotificationObserver,
       public extensions::ExtensionToolbarModel::Observer {
  public:
   ExtensionServiceObserverBridge(BrowserActionsController* owner,
                                  Browser* browser)
@@ skipping 42 matching lines @@
   }
 
   void ToolbarExtensionRemoved(const Extension* extension) override {
     [owner_ removeActionButtonForExtension:extension];
     [owner_ resizeContainerAndAnimate:NO];
   }
 
   void ToolbarExtensionMoved(const Extension* extension, int index) override {}
 
   void ToolbarExtensionUpdated(const Extension* extension) override {
-    BrowserActionButton* button = [owner_ buttonForExtension:extension];
+    BrowserActionButton* button = [owner_ buttonForId:extension->id()];
     if (button)
       [button updateState];
   }
 
   bool ShowExtensionActionPopup(const Extension* extension,
                                 bool grant_active_tab) override {
     // Do not override other popups and only show in active window.
     ExtensionPopupController* popup = [ExtensionPopupController popup];
     if (popup || !browser_->window()->IsActive())
       return false;
 
-    BrowserActionButton* button = [owner_ buttonForExtension:extension];
-    return button && [owner_ browserActionClicked:button
-                                      shouldGrant:grant_active_tab];
+    BrowserActionButton* button = [owner_ buttonForId:extension->id()];
+    return button && [button viewController]->ExecuteAction(grant_active_tab);
   }
 
   void ToolbarVisibleCountChanged() override {}
 
   void ToolbarHighlightModeChanged(bool is_highlighting) override {}
 
   Browser* GetBrowser() override { return browser_; }
 
  private:
   // The object we need to inform when we get a notification. Weak. Owns us.
@@ skipping 81 matching lines @@
 
 - (void)dealloc {
   if (toolbarModel_)
     toolbarModel_->RemoveObserver(observer_.get());
 
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
 - (void)update {
-  for (BrowserActionButton* button in [buttons_ allValues]) {
-    [button setTabId:[self currentTabId]];
+  for (BrowserActionButton* button in [buttons_ allValues])
     [button updateState];
-  }
 }
 
 - (NSUInteger)buttonCount {
   return [buttons_ count];
 }
 
 - (NSUInteger)visibleButtonCount {
   return [self buttonCount] - [hiddenButtons_ count];
 }
 
 - (void)resizeContainerAndAnimate:(BOOL)animate {
   int iconCount = toolbarModel_->GetVisibleIconCount();
   if (iconCount < 0)  // If no buttons are hidden.
     iconCount = [self buttonCount];
 
   [containerView_ resizeToWidth:[self containerWidthWithButtonCount:iconCount]
                         animate:animate];
   NSRect frame = animate ? [containerView_ animationEndFrame] :
                            [containerView_ frame];
 
   [self showChevronIfNecessaryInFrame:frame animate:animate];
 
   if (!animate) {
     [[NSNotificationCenter defaultCenter]
         postNotificationName:kBrowserActionVisibilityChangedNotification
                       object:self];
   }
 }
 
-- (NSView*)browserActionViewForExtension:(const Extension*)extension {
-  for (BrowserActionButton* button in [buttons_ allValues]) {
-    if ([button extension] == extension)
-      return button;
-  }
-  NOTREACHED();
-  return nil;
-}
-
 - (CGFloat)savedWidth {
   if (!toolbarModel_)
     return 0;
 
   int savedButtonCount = toolbarModel_->GetVisibleIconCount();
   if (savedButtonCount < 0 ||  // all icons are visible
       static_cast<NSUInteger>(savedButtonCount) > [self buttonCount])
     savedButtonCount = [self buttonCount];
   return [self containerWidthWithButtonCount:savedButtonCount];
 }
 
-- (NSPoint)popupPointForBrowserAction:(const Extension*)extension {
-  if (!extensions::ExtensionActionManager::Get(profile_)->
-      GetBrowserAction(*extension)) {
-    return NSZeroPoint;
-  }
-
-  NSButton* button = [self buttonForExtension:extension];
+- (NSPoint)popupPointForId:(const std::string&)id {
+  NSButton* button = [self buttonForId:id];
   if (!button)
     return NSZeroPoint;
 
   if ([hiddenButtons_ containsObject:button])
     button = chevronMenuButton_.get();
 
   // Anchor point just above the center of the bottom.
   const NSRect bounds = [button bounds];
   DCHECK([button isFlipped]);
   NSPoint anchor = NSMakePoint(NSMidX(bounds),
@@ skipping 17 matching lines @@
   if (effect == NSViewAnimationFadeInEffect) {
     return NO;
   } else if (effect == NSViewAnimationFadeOutEffect) {
     return YES;
   }
 
   NOTREACHED();
   return YES;
 }
 
-- (void)activateBrowserAction:(const std::string&)extension_id {
-  const Extension* extension = extensions::ExtensionRegistry::Get(
-      browser_->profile())->enabled_extensions().GetByID(extension_id);
-  if (!extension)
-    return;
-
-  BrowserActionButton* button = [self buttonForExtension:extension];
+- (void)activateBrowserAction:(const std::string&)id {
+  BrowserActionButton* button = [self buttonForId:id];
   // |button| can be nil when the browser action has its button hidden.
   if (button)
     [self browserActionClicked:button];
 }
 
+- (content::WebContents*)currentWebContents {
+  return browser_->tab_strip_model()->GetActiveWebContents();
+}
+
 #pragma mark -
 #pragma mark NSMenuDelegate
 
 - (void)menuNeedsUpdate:(NSMenu*)menu {
   [menu removeAllItems];
 
   // See menu_button.h for documentation on why this is needed.
   [menu addItemWithTitle:@"" action:nil keyEquivalent:@""];
 
   for (BrowserActionButton* button in hiddenButtons_.get()) {
-    NSString* name = base::SysUTF8ToNSString([button extension]->name());
+    NSString* name =
+        base::SysUTF16ToNSString([button viewController]->GetActionName());
     NSMenuItem* item =
         [menu addItemWithTitle:name
                         action:@selector(chevronItemSelected:)
                  keyEquivalent:@""];
     [item setRepresentedObject:button];
     [item setImage:[button compositedImage]];
     [item setTarget:self];
     [item setEnabled:[button isEnabled]];
   }
 }
@@ skipping 18 matching lines @@
 
 - (void)createActionButtonForExtension:(const Extension*)extension
                              withIndex:(NSUInteger)index {
   // Show the container if it's the first button. Otherwise it will be shown
   // already.
   if ([self buttonCount] == 0)
     [containerView_ setHidden:NO];
 
   NSRect buttonFrame = NSMakeRect(0.0, kBrowserActionOriginYOffset,
                                   kBrowserActionWidth, kBrowserActionHeight);
+  ExtensionAction* extensionAction =
+      extensions::ExtensionActionManager::Get(browser_->profile())->
+          GetExtensionAction(*extension);
+  DCHECK(extensionAction)
+        << "Don't create a BrowserActionButton if there is no browser action.";
+  scoped_ptr<ToolbarActionViewController> viewController(
+      new ExtensionActionViewController(extension, browser_, extensionAction));
+  // TODO(devlin): Move ContextMenuController stuff to
+  // ExtensionActionViewController.
+  ExtensionActionContextMenuController* menuController =
+      [[ExtensionActionContextMenuController alloc]
+          initWithExtension:extension
+                    browser:browser_
+            extensionAction:extensionAction];
   BrowserActionButton* newButton =
       [[[BrowserActionButton alloc]
          initWithFrame:buttonFrame
-             extension:extension
-               browser:browser_
-                 tabId:[self currentTabId]] autorelease];
+        viewController:viewController.Pass()
+            controller:self
+        menuController:menuController] autorelease];
   [newButton setTarget:self];
   [newButton setAction:@selector(browserActionClicked:)];
   NSString* buttonKey = base::SysUTF8ToNSString(extension->id());
   if (!buttonKey)
     return;
   [buttons_ setObject:newButton forKey:buttonKey];
 
   [self positionActionButtonsAndAnimate:NO];
 
   [[NSNotificationCenter defaultCenter]
@@ skipping 30 matching lines @@
   [containerView_ setMaxWidth:
       [self containerWidthWithButtonCount:[self buttonCount]]];
   [containerView_ setNeedsDisplay:YES];
 }
 
 - (void)positionActionButtonsAndAnimate:(BOOL)animate {
   NSUInteger i = 0;
   for (ExtensionList::const_iterator iter =
            toolbarModel_->toolbar_items().begin();
        iter != toolbarModel_->toolbar_items().end(); ++iter) {
-    BrowserActionButton* button = [self buttonForExtension:(iter->get())];
+    BrowserActionButton* button = [self buttonForId:(iter->get()->id())];
     if (!button)
       continue;
     if (![button isBeingDragged])
       [self moveButton:button toIndex:i animate:animate];
     ++i;
   }
 }
 
 - (void)updateButtonOpacity {
   for (BrowserActionButton* button in [buttons_ allValues]) {
     NSRect buttonFrame = [button frame];
     if (NSContainsRect([containerView_ bounds], buttonFrame)) {
       if ([button alphaValue] != 1.0)
         [button setAlphaValue:1.0];
 
       continue;
     }
     CGFloat intersectionWidth =
         NSWidth(NSIntersectionRect([containerView_ bounds], buttonFrame));
     CGFloat alpha = std::max(static_cast<CGFloat>(0.0),
                              intersectionWidth / NSWidth(buttonFrame));
     [button setAlphaValue:alpha];
     [button setNeedsDisplay:YES];
   }
 }
 
-- (BrowserActionButton*)buttonForExtension:(const Extension*)extension {
-  NSString* extensionId = base::SysUTF8ToNSString(extension->id());
-  DCHECK(extensionId);
-  if (!extensionId)
+- (BrowserActionButton*)buttonForId:(const std::string&)id {
+  NSString* nsId = base::SysUTF8ToNSString(id);
+  DCHECK(nsId);
+  if (!nsId)
     return nil;
-  return [buttons_ objectForKey:extensionId];
+  return [buttons_ objectForKey:nsId];
 }
 
 - (CGFloat)containerWidthWithButtonCount:(NSUInteger)buttonCount {
   // Left-side padding which works regardless of whether a button or
   // chevron leads.
   CGFloat width = kBrowserActionLeftPadding;
 
   // Include the buttons and padding between.
   if (buttonCount > 0) {
     width += buttonCount * kBrowserActionWidth;
@@ skipping 40 matching lines @@
 - (void)containerDragging:(NSNotification*)notification {
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kBrowserActionGrippyDraggingNotification
                     object:self];
 }
 
 - (void)containerDragFinished:(NSNotification*)notification {
   for (ExtensionList::const_iterator iter =
            toolbarModel_->toolbar_items().begin();
        iter != toolbarModel_->toolbar_items().end(); ++iter) {
-    BrowserActionButton* button = [self buttonForExtension:(iter->get())];
+    BrowserActionButton* button = [self buttonForId:(iter->get()->id())];
     NSRect buttonFrame = [button frame];
     if (NSContainsRect([containerView_ bounds], buttonFrame))
       continue;
 
     CGFloat intersectionWidth =
         NSWidth(NSIntersectionRect([containerView_ bounds], buttonFrame));
     // Pad the threshold by 5 pixels in order to have the buttons hide more
     // easily.
     if (([containerView_ grippyPinned] && intersectionWidth > 0) ||
         (intersectionWidth <= (NSWidth(buttonFrame) / 2) + 5.0)) {
@@ skipping 25 matching lines @@
   // Determine what index the dragged button should lie in, alter the model and
   // reposition the buttons.
   CGFloat dragThreshold = std::floor(kBrowserActionWidth / 2);
   BrowserActionButton* draggedButton = [notification object];
   NSRect draggedButtonFrame = [draggedButton frame];
 
   NSUInteger index = 0;
   for (ExtensionList::const_iterator iter =
            toolbarModel_->toolbar_items().begin();
        iter != toolbarModel_->toolbar_items().end(); ++iter) {
-    BrowserActionButton* button = [self buttonForExtension:(iter->get())];
+    BrowserActionButton* button = [self buttonForId:(iter->get()->id())];
     CGFloat intersectionWidth =
         NSWidth(NSIntersectionRect(draggedButtonFrame, [button frame]));
 
     if (intersectionWidth > dragThreshold && button != draggedButton &&
         ![button isAnimating] && index < [self visibleButtonCount]) {
-      toolbarModel_->MoveExtensionIcon([draggedButton extension]->id(), index);
+      toolbarModel_->MoveExtensionIcon([draggedButton viewController]->GetId(),
+                                       index);
       [self positionActionButtonsAndAnimate:YES];
       return;
     }
     ++index;
   }
 }
 
 - (void)actionButtonDragFinished:(NSNotification*)notification {
   [self showChevronIfNecessaryInFrame:[containerView_ frame] animate:YES];
   [self positionActionButtonsAndAnimate:YES];
@@ skipping 17 matching lines @@
     }
   } else if (![hiddenButtons_ containsObject:button]) {
     [hiddenButtons_ addObject:button];
     [button removeFromSuperview];
     [button setAlphaValue:0.0];
   }
 }
 
 - (BOOL)browserActionClicked:(BrowserActionButton*)button
                  shouldGrant:(BOOL)shouldGrant {
-  const Extension* extension = [button extension];
-  switch (extensions::ExtensionActionAPI::Get(profile_)->ExecuteExtensionAction(
-              extension, browser_, shouldGrant)) {
-    case ExtensionAction::ACTION_NONE:
-      break;
-    case ExtensionAction::ACTION_SHOW_POPUP: {
-      GURL popupUrl = extensions::ExtensionActionManager::Get(profile_)->
-          GetBrowserAction(*extension)->GetPopupUrl([self currentTabId]);
-      NSPoint arrowPoint = [self popupPointForBrowserAction:extension];
-      [ExtensionPopupController showURL:popupUrl
-                              inBrowser:browser_
-                             anchoredAt:arrowPoint
-                          arrowLocation:info_bubble::kTopRight
-                                devMode:NO];
-      return YES;
-    }
-  }
-  return NO;
+  return [button viewController]->ExecuteAction(shouldGrant);
 }
 
 - (BOOL)browserActionClicked:(BrowserActionButton*)button {
   return [self browserActionClicked:button
                         shouldGrant:YES];
 }
 
 - (void)showChevronIfNecessaryInFrame:(NSRect)frame animate:(BOOL)animate {
   [self setChevronHidden:([self buttonCount] == [self visibleButtonCount])
                  inFrame:frame
@@ skipping 67 matching lines @@
 - (void)chevronItemSelected:(id)menuItem {
   [self browserActionClicked:[menuItem representedObject]];
 }
 
 - (void)updateGrippyCursors {
   [containerView_ setCanDragLeft:[hiddenButtons_ count] > 0];
   [containerView_ setCanDragRight:[self visibleButtonCount] > 0];
   [[containerView_ window] invalidateCursorRectsForView:containerView_];
 }
 
-- (int)currentTabId {
-  content::WebContents* active_tab =
-      browser_->tab_strip_model()->GetActiveWebContents();
-  if (!active_tab)
-    return -1;
-
-  return SessionTabHelper::FromWebContents(active_tab)->session_id().id();
-}
-
 #pragma mark -
 #pragma mark Testing Methods
 
 - (BrowserActionButton*)buttonWithIndex:(NSUInteger)index {
   const extensions::ExtensionList& toolbar_items =
       toolbarModel_->toolbar_items();
   if (index < toolbar_items.size()) {
     const Extension* extension = toolbar_items[index].get();
     return [buttons_ objectForKey:base::SysUTF8ToNSString(extension->id())];
   }
   return nil;
 }
 
 @end