Limit overlap between BubbleManager and BaseBubbleController.

chrome/browser/ui/cocoa/base_bubble_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/base_bubble_controller.h"
 
 #include "base/logging.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/strings/string_util.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/info_bubble_view.h"
 #import "chrome/browser/ui/cocoa/info_bubble_window.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_model_observer_bridge.h"
+#include "components/bubble/bubble_controller.h"
 
 @interface BaseBubbleController (Private)
 - (void)registerForNotifications;
 - (void)updateOriginFromAnchor;
 - (void)activateTabWithContents:(content::WebContents*)newContents
                previousContents:(content::WebContents*)oldContents
                         atIndex:(NSInteger)index
                          reason:(int)reason;
 - (void)recordAnchorOffset;
 - (void)parentWindowDidResize:(NSNotification*)notification;
 - (void)parentWindowWillClose:(NSNotification*)notification;
 - (void)parentWindowWillToggleFullScreen:(NSNotification*)notification;
 - (void)closeCleanup;
+
+// Temporary methods to decide how to close the bubble controller.
+// TODO(hcarmona): remove these methods when all bubbles use the new API.
+- (void)closeBubbleWithReason:(BubbleCloseReason)reason;
+// Will be a noop in new bubble API because this is handled elsewhere.
+- (void)closeBubbleWithoutReason;

[groby-ooo-7-16, 2015/09/04 19:13:38]

Just call it closeBubble - it's not like we're actually closing without having a
reason for it :)

[hcarmona, 2015/09/09 23:33:02]

Done.

 @end
 
 @implementation BaseBubbleController
 
 @synthesize anchorPoint = anchor_;
 @synthesize bubble = bubble_;
 @synthesize shouldOpenAsKeyWindow = shouldOpenAsKeyWindow_;
 @synthesize shouldCloseOnResignKey = shouldCloseOnResignKey_;
+@synthesize bubbleReference = bubbleReference_;
 
 - (id)initWithWindowNibPath:(NSString*)nibPath
                parentWindow:(NSWindow*)parentWindow
                  anchoredAt:(NSPoint)anchoredAt {
   nibPath = [base::mac::FrameworkBundle() pathForResource:nibPath
                                                    ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibPath owner:self])) {
     [self setParentWindow:parentWindow];
     anchor_ = anchoredAt;
     shouldOpenAsKeyWindow_ = YES;
@@ skipping 172 matching lines @@
   DCHECK_EQ(parentWindow_, [notification object]);
   NSPoint newOrigin = NSMakePoint(NSMinX([parentWindow_ frame]),
                                   NSMaxY([parentWindow_ frame]));
   newOrigin.x -= anchorOffset_.x;
   newOrigin.y -= anchorOffset_.y;
   [self setAnchorPoint:newOrigin];
 }
 
 - (void)parentWindowWillClose:(NSNotification*)notification {
   [self setParentWindow:nil];
-  [self close];
+  [self closeBubbleWithoutReason];
 }
 
 - (void)parentWindowWillToggleFullScreen:(NSNotification*)notification {
   [self setParentWindow:nil];
-  [self close];
+  [self closeBubbleWithoutReason];
 }
 
 - (void)closeCleanup {
   if (eventTap_) {
     [NSEvent removeMonitor:eventTap_];
     eventTap_ = nil;
   }
   if (resignationObserver_) {
     [[NSNotificationCenter defaultCenter]
         removeObserver:resignationObserver_
                   name:NSWindowDidResignKeyNotification
                 object:nil];
     resignationObserver_ = nil;
   }
 
   tabStripObserverBridge_.reset();
 }
 
+- (void)closeBubbleWithReason:(BubbleCloseReason)reason {
+  if ([self bubbleReference])
+    [self bubbleReference]->CloseBubble(reason);
+  else
+    [self close];
+}
+
+- (void)closeBubbleWithoutReason {

[groby-ooo-7-16, 2015/09/04 19:13:38]

That's rather... icky. This means that we won't close at all if we have a
bubbleReference. Not sure this makes sense to me?

[hcarmona, 2015/09/04 20:58:01]

This should only be called where it's redundant for bubbles managed by
the bubble manager. I _could_ close the bubbles if we have a bubble
reference too, but then we'd be doing it in two places. Shouldn't be the
end of the world because we'd be removing it from the manager, but we'd
have duplicate BubbleClose for the same reason.

[groby-ooo-7-16, 2015/09/04 21:38:03]

Can we kill that duplication?

[hcarmona, 2015/09/04 21:49:39]

That's what this is attempting to do by not calling |CloseBubble| on the
bubble reference. The BubbleManager will notify the bubble to close when
the parent closes, when fullscreen is toggled, and when a tab changes.
Those functions should go away from this class when all bubbles are
using the bubble API.

+  if (![self bubbleReference])
+    [self close];
+}
+
 - (void)windowWillClose:(NSNotification*)notification {
   [self closeCleanup];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [self autorelease];
 }
 
 // We want this to be a child of a browser window.  addChildWindow:
 // (called from this function) will bring the window on-screen;
 // unfortunately, [NSWindowController showWindow:] will also bring it
 // on-screen (but will cause unexpected changes to the window's
@@ skipping 24 matching lines @@
   DCHECK_EQ([notification object], window);
 
   // If the window isn't visible, it is already closed, and this notification
   // has been sent as part of the closing operation, so no need to close.
   if (![window isVisible])
     return;
 
   // Don't close when explicily disabled, or if there's an attached sheet (e.g.
   // Open File dialog).
   if ([self shouldCloseOnResignKey] && ![window attachedSheet]) {
-    [self close];
+    [self closeBubbleWithReason:BUBBLE_CLOSE_FOCUS_LOST];
     return;
   }
 
   // The bubble should not receive key events when it is no longer key window,
   // so disable sharing parent key state. Share parent key state is only used
   // to enable the close/minimize/maximize buttons of the parent window when
   // the bubble has key state, so disabling it here is safe.
   InfoBubbleWindow* bubbleWindow =
       base::mac::ObjCCastStrict<InfoBubbleWindow>([self window]);
   [bubbleWindow setAllowShareParentKeyState:NO];
@@ skipping 52 matching lines @@
                           if (![[notif object] isSheet] &&
                               [NSApp keyWindow] != [self window])
                             [self windowDidResignKey:note];
                       }];
 }
 
 // By implementing this, ESC causes the window to go away.
 - (IBAction)cancel:(id)sender {
   // This is not a "real" cancel as potential changes to the radio group are not
   // undone. That's ok.
-  [self close];
+  [self closeBubbleWithReason:BUBBLE_CLOSE_CANCELED];
 }
 
 // Takes the |anchor_| point and adjusts the window's origin accordingly.
 - (void)updateOriginFromAnchor {
   NSWindow* window = [self window];
   NSPoint origin = anchor_;
 
   switch ([bubble_ alignment]) {
     case info_bubble::kAlignArrowToAnchor: {
       NSSize offsets = NSMakeSize(info_bubble::kBubbleArrowXOffset +
@@ skipping 39 matching lines @@
 
   origin.y -= NSHeight([window frame]);
   [window setFrameOrigin:origin];
 }
 
 - (void)activateTabWithContents:(content::WebContents*)newContents
                previousContents:(content::WebContents*)oldContents
                         atIndex:(NSInteger)index
                          reason:(int)reason {
   // The user switched tabs; close.
-  [self close];
+  [self closeBubbleWithoutReason];
 }
 
 @end  // BaseBubbleController