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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #import "chrome/browser/ui/cocoa/extensions/extension_popup_controller.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/callback.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/devtools/devtools_window.h"
  12 #include "chrome/browser/extensions/extension_view_host.h"
  13 #include "chrome/browser/extensions/extension_view_host_factory.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #import "chrome/browser/ui/cocoa/browser_window_cocoa.h"
  17 #import "chrome/browser/ui/cocoa/extensions/extension_view_mac.h"
  18 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
  19 #include "components/web_modal/web_contents_modal_dialog_manager.h"
  20 #include "content/public/browser/devtools_agent_host.h"
  21 #include "content/public/browser/devtools_manager.h"
  22 #include "content/public/browser/notification_details.h"
  23 #include "content/public/browser/notification_registrar.h"
  24 #include "content/public/browser/notification_source.h"
  25 #include "ui/base/cocoa/window_size_constants.h"
  26
  27 using content::BrowserContext;
  28 using content::RenderViewHost;
  29
  30 namespace {
  31 // The duration for any animations that might be invoked by this controller.
  32 const NSTimeInterval kAnimationDuration = 0.2;
  33
  34 // There should only be one extension popup showing at one time. Keep a
  35 // reference to it here.
  36 static ExtensionPopupController* gPopup;
  37
  38 // Given a value and a rage, clamp the value into the range.
  39 CGFloat Clamp(CGFloat value, CGFloat min, CGFloat max) {
  40   return std::max(min, std::min(max, value));
  41 }
  42
  43 }  // namespace
  44
  45 @interface ExtensionPopupController (Private)
  46 // Callers should be using the public static method for initialization.
  47 // NOTE: This takes ownership of |host|.
  48 - (id)initWithHost:(extensions::ExtensionViewHost*)host
  49       parentWindow:(NSWindow*)parentWindow
  50         anchoredAt:(NSPoint)anchoredAt
  51      arrowLocation:(info_bubble::BubbleArrowLocation)arrowLocation
  52            devMode:(BOOL)devMode;
  53
  54 // Called when the extension's hosted NSView has been resized.
  55 - (void)extensionViewFrameChanged;
  56
  57 // Called when the extension's size changes.
  58 - (void)onSizeChanged:(NSSize)newSize;
  59
  60 // Called when the extension view is shown.
  61 - (void)onViewDidShow;
  62 @end
  63
  64 class ExtensionPopupContainer : public ExtensionViewMac::Container {
  65  public:
  66   explicit ExtensionPopupContainer(ExtensionPopupController* controller)
  67       : controller_(controller) {
  68   }
  69
  70   virtual void OnExtensionSizeChanged(
  71       ExtensionViewMac* view,
  72       const gfx::Size& new_size) OVERRIDE {
  73     [controller_ onSizeChanged:
  74         NSMakeSize(new_size.width(), new_size.height())];
  75   }
  76
  77   virtual void OnExtensionViewDidShow(ExtensionViewMac* view) OVERRIDE {
  78     [controller_ onViewDidShow];
  79   }
  80
  81  private:
  82   ExtensionPopupController* controller_; // Weak; owns this.
  83 };
  84
  85 class DevtoolsNotificationBridge : public content::NotificationObserver {
  86  public:
  87   explicit DevtoolsNotificationBridge(ExtensionPopupController* controller)
  88     : controller_(controller),
  89       render_view_host_([controller_ extensionViewHost]->render_view_host()),
  90       devtools_callback_(base::Bind(
  91           &DevtoolsNotificationBridge::OnDevToolsStateChanged,
  92           base::Unretained(this))) {
  93     content::DevToolsManager::GetInstance()->AddAgentStateCallback(
  94         devtools_callback_);
  95   }
  96
  97   virtual ~DevtoolsNotificationBridge() {
  98     content::DevToolsManager::GetInstance()->RemoveAgentStateCallback(
  99         devtools_callback_);
 100   }
 101
 102   void OnDevToolsStateChanged(content::DevToolsAgentHost* agent_host,
 103                               bool attached) {
 104     if (agent_host->GetRenderViewHost() != render_view_host_)
 105       return;
 106
 107     if (attached) {
 108       // Set the flag on the controller so the popup is not hidden when
 109       // the dev tools get focus.
 110       [controller_ setBeingInspected:YES];
 111     } else {
 112       // Allow the devtools to finish detaching before we close the popup.
 113       [controller_ performSelector:@selector(close)
 114                         withObject:nil
 115                         afterDelay:0.0];
 116     }
 117   }
 118
 119   virtual void Observe(
 120       int type,
 121       const content::NotificationSource& source,
 122       const content::NotificationDetails& details) OVERRIDE {
 123     switch (type) {
 124       case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING: {
 125         if (content::Details<extensions::ExtensionViewHost>(
 126                 [controller_ extensionViewHost]) == details) {
 127           [controller_ showDevTools];
 128         }
 129         break;
 130       }
 131       default: {
 132         NOTREACHED() << "Received unexpected notification";
 133         break;
 134       }
 135     };
 136   }
 137
 138  private:
 139   ExtensionPopupController* controller_;
 140   // RenderViewHost for controller. Hold onto this separately because we need to
 141   // know what it is for notifications, but our ExtensionViewHost may not be
 142   // valid.
 143   RenderViewHost* render_view_host_;
 144   base::Callback<void(content::DevToolsAgentHost*, bool)> devtools_callback_;
 145 };
 146
 147 @implementation ExtensionPopupController
 148
 149 - (id)initWithHost:(extensions::ExtensionViewHost*)host
 150       parentWindow:(NSWindow*)parentWindow
 151         anchoredAt:(NSPoint)anchoredAt
 152      arrowLocation:(info_bubble::BubbleArrowLocation)arrowLocation
 153            devMode:(BOOL)devMode {
 154   base::scoped_nsobject<InfoBubbleWindow> window([[InfoBubbleWindow alloc]
 155       initWithContentRect:ui::kWindowSizeDeterminedLater
 156                 styleMask:NSBorderlessWindowMask
 157                   backing:NSBackingStoreBuffered
 158                     defer:YES]);
 159   if (!window.get())
 160     return nil;
 161
 162   anchoredAt = [parentWindow convertBaseToScreen:anchoredAt];
 163   if ((self = [super initWithWindow:window
 164                        parentWindow:parentWindow
 165                          anchoredAt:anchoredAt])) {
 166     host_.reset(host);
 167     beingInspected_ = devMode;
 168     ignoreWindowDidResignKey_ = NO;
 169
 170     InfoBubbleView* view = self.bubble;
 171     [view setArrowLocation:arrowLocation];
 172
 173     extensionView_ = host->view()->native_view();
 174     container_.reset(new ExtensionPopupContainer(self));
 175     host->view()->set_container(container_.get());
 176
 177     NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
 178     [center addObserver:self
 179                selector:@selector(extensionViewFrameChanged)
 180                    name:NSViewFrameDidChangeNotification
 181                  object:extensionView_];
 182
 183     [view addSubview:extensionView_];
 184
 185     notificationBridge_.reset(new DevtoolsNotificationBridge(self));
 186     registrar_.reset(new content::NotificationRegistrar);
 187     if (beingInspected_) {
 188       // Listen for the extension to finish loading so the dev tools can be
 189       // opened.
 190       registrar_->Add(notificationBridge_.get(),
 191                       chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
 192                       content::Source<BrowserContext>(host->browser_context()));
 193     }
 194   }
 195   return self;
 196 }
 197
 198 - (void)dealloc {
 199   [[NSNotificationCenter defaultCenter] removeObserver:self];
 200   [super dealloc];
 201 }
 202
 203 - (void)showDevTools {
 204   DevToolsWindow::OpenDevToolsWindow(host_->render_view_host());
 205 }
 206
 207 - (void)close {
 208   // |windowWillClose:| could have already been called. http://crbug.com/279505
 209   if (host_) {
 210     web_modal::WebContentsModalDialogManager* modalDialogManager =
 211         web_modal::WebContentsModalDialogManager::FromWebContents(
 212             host_->host_contents());
 213     if (modalDialogManager &&
 214         modalDialogManager->IsDialogActive()) {
 215       return;
 216     }
 217   }
 218   [super close];
 219 }
 220
 221 - (void)windowWillClose:(NSNotification *)notification {
 222   [super windowWillClose:notification];
 223   gPopup = nil;
 224   if (host_->view())
 225     host_->view()->set_container(NULL);
 226   host_.reset();
 227 }
 228
 229 - (void)windowDidResignKey:(NSNotification*)notification {
 230   // |windowWillClose:| could have already been called. http://crbug.com/279505
 231   if (host_) {
 232     // When a modal dialog is opened on top of the popup and when it's closed,
 233     // it steals key-ness from the popup. Don't close the popup when this
 234     // happens. There's an extra windowDidResignKey: notification after the
 235     // modal dialog closes that should also be ignored.
 236     web_modal::WebContentsModalDialogManager* modalDialogManager =
 237         web_modal::WebContentsModalDialogManager::FromWebContents(
 238             host_->host_contents());
 239     if (modalDialogManager &&
 240         modalDialogManager->IsDialogActive()) {
 241       ignoreWindowDidResignKey_ = YES;
 242       return;
 243     }
 244     if (ignoreWindowDidResignKey_) {
 245       ignoreWindowDidResignKey_ = NO;
 246       return;
 247     }
 248   }
 249   if (!beingInspected_)
 250     [super windowDidResignKey:notification];
 251 }
 252
 253 - (BOOL)isClosing {
 254   return [static_cast<InfoBubbleWindow*>([self window]) isClosing];
 255 }
 256
 257 - (extensions::ExtensionViewHost*)extensionViewHost {
 258   return host_.get();
 259 }
 260
 261 - (void)setBeingInspected:(BOOL)beingInspected {
 262   beingInspected_ = beingInspected;
 263 }
 264
 265 + (ExtensionPopupController*)showURL:(GURL)url
 266                            inBrowser:(Browser*)browser
 267                           anchoredAt:(NSPoint)anchoredAt
 268                        arrowLocation:(info_bubble::BubbleArrowLocation)
 269                                          arrowLocation
 270                              devMode:(BOOL)devMode {
 271   DCHECK([NSThread isMainThread]);
 272   DCHECK(browser);
 273   if (!browser)
 274     return nil;
 275
 276   extensions::ExtensionViewHost* host =
 277       extensions::ExtensionViewHostFactory::CreatePopupHost(url, browser);
 278   DCHECK(host);
 279   if (!host)
 280     return nil;
 281
 282   // Make absolutely sure that no popups are leaked.
 283   if (gPopup) {
 284     if ([[gPopup window] isVisible])
 285       [gPopup close];
 286
 287     [gPopup autorelease];
 288     gPopup = nil;
 289   }
 290   DCHECK(!gPopup);
 291
 292   // Takes ownership of |host|. Also will autorelease itself when the popup is
 293   // closed, so no need to do that here.
 294   gPopup = [[ExtensionPopupController alloc]
 295       initWithHost:host
 296       parentWindow:browser->window()->GetNativeWindow()
 297         anchoredAt:anchoredAt
 298      arrowLocation:arrowLocation
 299            devMode:devMode];
 300   return gPopup;
 301 }
 302
 303 + (ExtensionPopupController*)popup {
 304   return gPopup;
 305 }
 306
 307 - (void)extensionViewFrameChanged {
 308   // If there are no changes in the width or height of the frame, then ignore.
 309   if (NSEqualSizes([extensionView_ frame].size, extensionFrame_.size))
 310     return;
 311
 312   extensionFrame_ = [extensionView_ frame];
 313   // Constrain the size of the view.
 314   [extensionView_ setFrameSize:NSMakeSize(
 315       Clamp(NSWidth(extensionFrame_),
 316             ExtensionViewMac::kMinWidth,
 317             ExtensionViewMac::kMaxWidth),
 318       Clamp(NSHeight(extensionFrame_),
 319             ExtensionViewMac::kMinHeight,
 320             ExtensionViewMac::kMaxHeight))];
 321
 322   // Pad the window by half of the rounded corner radius to prevent the
 323   // extension's view from bleeding out over the corners.
 324   CGFloat inset = info_bubble::kBubbleCornerRadius / 2.0;
 325   [extensionView_ setFrameOrigin:NSMakePoint(inset, inset)];
 326
 327   NSRect frame = [extensionView_ frame];
 328   frame.size.height += info_bubble::kBubbleArrowHeight +
 329                        info_bubble::kBubbleCornerRadius;
 330   frame.size.width += info_bubble::kBubbleCornerRadius;
 331   frame = [extensionView_ convertRect:frame toView:nil];
 332   // Adjust the origin according to the height and width so that the arrow is
 333   // positioned correctly at the middle and slightly down from the button.
 334   NSPoint windowOrigin = self.anchorPoint;
 335   NSSize offsets = NSMakeSize(info_bubble::kBubbleArrowXOffset +
 336                                   info_bubble::kBubbleArrowWidth / 2.0,
 337                               info_bubble::kBubbleArrowHeight / 2.0);
 338   offsets = [extensionView_ convertSize:offsets toView:nil];
 339   windowOrigin.x -= NSWidth(frame) - offsets.width;
 340   windowOrigin.y -= NSHeight(frame) - offsets.height;
 341   frame.origin = windowOrigin;
 342
 343   // Is the window still animating in? If so, then cancel that and create a new
 344   // animation setting the opacity and new frame value. Otherwise the current
 345   // animation will continue after this frame is set, reverting the frame to
 346   // what it was when the animation started.
 347   NSWindow* window = [self window];
 348   id animator = [window animator];
 349   if ([window isVisible] &&
 350       ([animator alphaValue] < 1.0 ||
 351        !NSEqualRects([window frame], [animator frame]))) {
 352     [NSAnimationContext beginGrouping];
 353     [[NSAnimationContext currentContext] setDuration:kAnimationDuration];
 354     [animator setAlphaValue:1.0];
 355     [animator setFrame:frame display:YES];
 356     [NSAnimationContext endGrouping];
 357   } else {
 358     [window setFrame:frame display:YES];
 359   }
 360
 361   // A NSViewFrameDidChangeNotification won't be sent until the extension view
 362   // content is loaded. The window is hidden on init, so show it the first time
 363   // the notification is fired (and consequently the view contents have loaded).
 364   if (![window isVisible]) {
 365     [self showWindow:self];
 366   }
 367 }
 368
 369 - (void)onSizeChanged:(NSSize)newSize {
 370   // When we update the size, the window will become visible. Stay hidden until
 371   // the host is loaded.
 372   pendingSize_ = newSize;
 373   if (!host_->did_stop_loading())
 374     return;
 375
 376   // No need to use CA here, our caller calls us repeatedly to animate the
 377   // resizing.
 378   NSRect frame = [extensionView_ frame];
 379   frame.size = newSize;
 380
 381   // |new_size| is in pixels. Convert to view units.
 382   frame.size = [extensionView_ convertSize:frame.size fromView:nil];
 383
 384   [extensionView_ setFrame:frame];
 385   [extensionView_ setNeedsDisplay:YES];
 386 }
 387
 388 - (void)onViewDidShow {
 389   [self onSizeChanged:pendingSize_];
 390 }
 391
 392 - (void)windowDidResize:(NSNotification*)notification {
 393   // Let the extension view know, so that it can tell plugins.
 394   if (host_->view())
 395     host_->view()->WindowFrameChanged();
 396 }
 397
 398 - (void)windowDidMove:(NSNotification*)notification {
 399   // Let the extension view know, so that it can tell plugins.
 400   if (host_->view())
 401     host_->view()->WindowFrameChanged();
 402 }
 403
 404 // Private (TestingAPI)
 405 - (NSView*)view {
 406   return extensionView_;
 407 }
 408
 409 // Private (TestingAPI)
 410 + (NSSize)minPopupSize {
 411   NSSize minSize = {ExtensionViewMac::kMinWidth, ExtensionViewMac::kMinHeight};
 412   return minSize;
 413 }
 414
 415 // Private (TestingAPI)
 416 + (NSSize)maxPopupSize {
 417   NSSize maxSize = {ExtensionViewMac::kMaxWidth, ExtensionViewMac::kMaxHeight};
 418   return maxSize;
 419 }
 420
 421 @end