Mac Changes for BubbleManager

chrome/browser/ui/cocoa/website_settings/permission_bubble_controller.mm

 // Copyright 2014 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/website_settings/permission_bubble_controller.h"
 
 #include <algorithm>
 
 #include "base/mac/bind_objc_block.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_window.h"
 #import "chrome/browser/ui/chrome_style.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
 #import "chrome/browser/ui/cocoa/constrained_window/constrained_window_button.h"
 #import "chrome/browser/ui/cocoa/hover_close_button.h"
 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
+#import "chrome/browser/ui/cocoa/location_bar/location_bar_view_mac.h"
 #include "chrome/browser/ui/cocoa/website_settings/permission_bubble_cocoa.h"
 #include "chrome/browser/ui/cocoa/website_settings/permission_selector_button.h"
 #include "chrome/browser/ui/cocoa/website_settings/split_block_button.h"
 #include "chrome/browser/ui/cocoa/website_settings/website_settings_utils_cocoa.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
-#include "chrome/browser/ui/website_settings/permission_bubble_view.h"
 #include "chrome/browser/ui/website_settings/permission_menu_model.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/user_metrics.h"
 #include "skia/ext/skia_utils_mac.h"
 #import "ui/base/cocoa/controls/hyperlink_text_view.h"
 #import "ui/base/cocoa/menu_controller.h"
 #include "ui/base/cocoa/window_size_constants.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/base/models/simple_menu_model.h"
@@ skipping 38 matching lines @@
 // multiple permissions in the bubble.
 @interface AllowBlockMenuButton : NSPopUpButton {
  @private
   scoped_ptr<PermissionMenuModel> menuModel_;
   base::scoped_nsobject<MenuController> menuController_;
 }
 
 - (id)initForURL:(const GURL&)url
          allowed:(BOOL)allow
            index:(int)index
-        delegate:(PermissionBubbleView::Delegate*)delegate;
+         manager:(PermissionBubbleManager*)manager;
 
 // Returns the maximum width of its possible titles.
 - (CGFloat)maximumTitleWidth;
 @end
 
 @implementation AllowBlockMenuButton
 
 - (id)initForURL:(const GURL&)url
          allowed:(BOOL)allow
            index:(int)index
-        delegate:(PermissionBubbleView::Delegate*)delegate {
+         manager:(PermissionBubbleManager*)manager {
   if (self = [super initWithFrame:NSZeroRect pullsDown:NO]) {
     ContentSetting setting =
         allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
     [self setFont:[NSFont systemFontOfSize:[NSFont smallSystemFontSize]]];
     [self setBordered:NO];
 
-    __block PermissionBubbleView::Delegate* blockDelegate = delegate;
+    __block PermissionBubbleManager* blockManager = manager;
     __block AllowBlockMenuButton* blockSelf = self;
     PermissionMenuModel::ChangeCallback changeCallback =
         base::BindBlock(^(const WebsiteSettingsUI::PermissionInfo& permission) {
-            blockDelegate->ToggleAccept(
-                index, permission.setting == CONTENT_SETTING_ALLOW);
-            [blockSelf setFrameSize:
-                SizeForWebsiteSettingsButtonTitle(blockSelf,
-                                                  [blockSelf title])];
+          blockManager->ToggleAccept(
+              index, permission.setting == CONTENT_SETTING_ALLOW);
+          [blockSelf setFrameSize:SizeForWebsiteSettingsButtonTitle(
+                                      blockSelf, [blockSelf title])];
         });
 
     menuModel_.reset(new PermissionMenuModel(url, setting, changeCallback));
     menuController_.reset([[MenuController alloc] initWithModel:menuModel_.get()
                                          useWithPopUpButtonCell:NO]);
     [self setMenu:[menuController_ menu]];
     [self selectItemAtIndex:menuModel_->GetIndexOfCommandId(setting)];
     // Although the frame is reset, below, this sizes the cell properly.
     [self sizeToFit];
     // Adjust the size to fit the current title.  Using only -sizeToFit leaves
@@ skipping 88 matching lines @@
 + (CGFloat)matchWidthsOf:(NSView*)viewA andOf:(NSView*)viewB;
 
 // Sets the offset of |viewA| so that its vertical center is aligned with the
 // vertical center of |viewB|.
 + (void)alignCenterOf:(NSView*)viewA verticallyToCenterOf:(NSView*)viewB;
 
 @end
 
 @implementation PermissionBubbleController
 
-- (id)initWithParentWindow:(NSWindow*)parentWindow
-                    bridge:(PermissionBubbleCocoa*)bridge {
-  DCHECK(parentWindow);
+- (id)initWithBrowser:(Browser*)browser bridge:(PermissionBubbleCocoa*)bridge {
+  DCHECK(browser);
   DCHECK(bridge);
+  browser_ = browser;
   base::scoped_nsobject<PermissionBubbleWindow> window(
       [[PermissionBubbleWindow alloc]
           initWithContentRect:ui::kWindowSizeDeterminedLater
                     styleMask:NSBorderlessWindowMask
                       backing:NSBackingStoreBuffered
                         defer:NO]);
   [window setAllowedAnimations:info_bubble::kAnimateNone];
   [window setReleasedWhenClosed:NO];
   if ((self = [super initWithWindow:window
-                       parentWindow:parentWindow
+                       parentWindow:[self getExpectedParentWindow]
                          anchoredAt:NSZeroPoint])) {
     [self setShouldCloseOnResignKey:NO];
     [self setShouldOpenAsKeyWindow:YES];
-    [[self bubble] setArrowLocation:bridge->GetArrowLocation()];
+    [[self bubble] setArrowLocation:[self getExpectedArrowLocation]];
     bridge_ = bridge;
     NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
     [center addObserver:self
                selector:@selector(parentWindowDidMove:)
                    name:NSWindowDidMoveNotification
-                 object:parentWindow];
+                 object:[self getExpectedParentWindow]];
   }
   return self;
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
   bridge_->OnBubbleClosing();
   [super windowWillClose:notification];
 }
 
 - (void)parentWindowWillToggleFullScreen:(NSNotification*)notification {
   // Override the base class implementation, which would have closed the bubble.
 }
 
 - (void)parentWindowDidResize:(NSNotification*)notification {
   DCHECK(bridge_);
-  [self setAnchorPoint:bridge_->GetAnchorPoint()];
+  [self setAnchorPoint:[self getExpectedAnchorPoint]];
 }
 
 - (void)parentWindowDidMove:(NSNotification*)notification {
   DCHECK(bridge_);
-  [self setAnchorPoint:bridge_->GetAnchorPoint()];
+  [self setAnchorPoint:[self getExpectedAnchorPoint]];
 }
 
-- (void)showAtAnchor:(NSPoint)anchorPoint
-         withDelegate:(PermissionBubbleView::Delegate*)delegate
-          forRequests:(const std::vector<PermissionBubbleRequest*>&)requests
-         acceptStates:(const std::vector<bool>&)acceptStates {
+- (void)showWithManager:(PermissionBubbleManager*)manager
+            forRequests:(const std::vector<PermissionBubbleRequest*>&)requests
+           acceptStates:(const std::vector<bool>&)acceptStates {
   DCHECK(!requests.empty());
-  DCHECK(delegate);
-  delegate_ = delegate;
+  DCHECK(manager);
+  manager_ = manager;
 
   NSView* contentView = [[self window] contentView];
   [contentView setSubviews:@[]];
 
   BOOL singlePermission = requests.size() == 1;
 
   // Create one button to use as a guide for the permissions' y-offsets.
   base::scoped_nsobject<NSView> allowOrOkButton;
   if (singlePermission) {
     NSString* allowTitle = l10n_util::GetNSString(IDS_PERMISSION_ALLOW);
@@ skipping 127 matching lines @@
     // within -setAnchorPoint) causes flickering.  Avoid the flickering by
     // manually adjusting the new frame's origin so that the top left stays the
     // same, and only calling -setFrame.
     NSRect currentWindowFrame = [[self window] frame];
     bubbleFrame.origin = currentWindowFrame.origin;
     bubbleFrame.origin.y = bubbleFrame.origin.y +
         currentWindowFrame.size.height - bubbleFrame.size.height;
     [[self window] setFrame:bubbleFrame display:YES];
   } else {
     [[self window] setFrame:bubbleFrame display:NO];
-    [self setAnchorPoint:anchorPoint];
+    [self setAnchorPoint:[self getExpectedAnchorPoint]];
     [self showWindow:nil];
     [[self window] makeFirstResponder:nil];
     [[self window] setInitialFirstResponder:allowOrOkButton.get()];
   }
 }
 
+- (void)updateAnchorPosition {
+  [self setParentWindow:[self getExpectedParentWindow]];
+  [self setAnchorPoint:[self getExpectedAnchorPoint]];
+}
+
+- (NSPoint)getExpectedAnchorPoint {
+  NSPoint anchor;
+  if ([self hasLocationBar]) {
+    LocationBarViewMac* location_bar =
+        [[[self getExpectedParentWindow] windowController] locationBarBridge];
+    anchor = location_bar->GetPageInfoBubblePoint();
+  } else {
+    // Center the bubble if there's no location bar.
+    NSView* content_view = [[self getExpectedParentWindow] contentView];
+    anchor.y = NSMaxY(content_view.frame);
+    anchor.x = NSMidX(content_view.frame);
+  }
+
+  return [[self getExpectedParentWindow] convertBaseToScreen:anchor];
+}
+
+- (BOOL)hasLocationBar {
+  return browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
+}
+
+- (info_bubble::BubbleArrowLocation)getExpectedArrowLocation {
+  return [self hasLocationBar] ? info_bubble::kTopLeft : info_bubble::kNoArrow;
+}
+
+- (NSWindow*)getExpectedParentWindow {
+  return browser_->window()->GetNativeWindow();
+}
+
 - (NSView*)labelForRequest:(PermissionBubbleRequest*)request {
   DCHECK(request);
   base::scoped_nsobject<NSView> permissionView(
       [[NSView alloc] initWithFrame:NSZeroRect]);
   base::scoped_nsobject<NSImageView> permissionIcon(
       [[NSImageView alloc] initWithFrame:NSZeroRect]);
   [permissionIcon setImage:ui::ResourceBundle::GetSharedInstance().
       GetNativeImageNamed(request->GetIconID()).ToNSImage()];
   [permissionIcon setFrameSize:kPermissionIconSize];
   [permissionView addSubview:permissionIcon];
@@ skipping 48 matching lines @@
   NSRect titleFrame = [titleView frame];
   [titleView setFrameSize:NSMakeSize(NSWidth(titleFrame) + kTitlePaddingX,
                                      NSHeight(titleFrame))];
   return titleView.autorelease();
 }
 
 - (NSView*)menuForRequest:(PermissionBubbleRequest*)request
                   atIndex:(int)index
                     allow:(BOOL)allow {
   DCHECK(request);
-  DCHECK(delegate_);
+  DCHECK(manager_);
   base::scoped_nsobject<AllowBlockMenuButton> button(
       [[AllowBlockMenuButton alloc] initForURL:request->GetRequestingHostname()
                                        allowed:allow
                                          index:index
-                                      delegate:delegate_]);
+                                       manager:manager_]);
   return button.autorelease();
 }
 
 - (NSView*)buttonWithTitle:(NSString*)title
                     action:(SEL)action {
   base::scoped_nsobject<NSButton> button(
       [[ConstrainedWindowButton alloc] initWithFrame:NSZeroRect]);
   [button setButtonType:NSMomentaryPushInButton];
   [button setTitle:title];
   [button setTarget:self];
@@ skipping 12 matching lines @@
   int dimension = chrome_style::GetCloseButtonSize();
   NSRect frame = NSMakeRect(0, 0, dimension, dimension);
   base::scoped_nsobject<NSButton> button(
       [[WebUIHoverCloseButton alloc] initWithFrame:frame]);
   [button setAction:@selector(onClose:)];
   [button setTarget:self];
   return button.autorelease();
 }
 
 - (void)ok:(id)sender {
-  DCHECK(delegate_);
-  delegate_->Accept();
+  DCHECK(manager_);
+  manager_->Accept();
 }
 
 - (void)onAllow:(id)sender {
-  DCHECK(delegate_);
-  delegate_->Accept();
+  DCHECK(manager_);
+  manager_->Accept();
 }
 
 - (void)onBlock:(id)sender {
-  DCHECK(delegate_);
-  delegate_->Deny();
+  DCHECK(manager_);
+  manager_->Deny();
 }
 
 - (void)onClose:(id)sender {
-  DCHECK(delegate_);
-  delegate_->Closing();
+  DCHECK(manager_);
+  manager_->Closing();
 }
 
 - (void)activateTabWithContents:(content::WebContents*)newContents
                previousContents:(content::WebContents*)oldContents
                         atIndex:(NSInteger)index
                          reason:(int)reason {
   // The show/hide of this bubble is handled by the PermissionBubbleManager.
   // So bypass the base class, which would close the bubble here.
 }
 
 + (CGFloat)matchWidthsOf:(NSView*)viewA andOf:(NSView*)viewB {
   NSRect frameA = [viewA frame];
   NSRect frameB = [viewB frame];
   CGFloat width = std::max(NSWidth(frameA), NSWidth(frameB));
   [viewA setFrameSize:NSMakeSize(width, NSHeight(frameA))];
   [viewB setFrameSize:NSMakeSize(width, NSHeight(frameB))];
   return width;
 }
 
 + (void)alignCenterOf:(NSView*)viewA verticallyToCenterOf:(NSView*)viewB {
   NSRect frameA = [viewA frame];
   NSRect frameB = [viewB frame];
   frameA.origin.y =
       NSMinY(frameB) + std::floor((NSHeight(frameB) - NSHeight(frameA)) / 2);
   [viewA setFrameOrigin:frameA.origin];
 }
 
 @end  // implementation PermissionBubbleController