[Mac] Delay TabContents::Close() when event-tracking.

chrome/browser/tab_contents/tab_contents_view_mac.mm

 // Copyright (c) 2006-2008 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 <Carbon/Carbon.h>
 
 #include "chrome/browser/tab_contents/tab_contents_view_mac.h"
 
 #include <string>
 
+#import "base/chrome_application_mac.h"
 #include "chrome/browser/browser.h" // TODO(beng): this dependency is awful.
 #import "chrome/browser/cocoa/focus_tracker.h"
 #import "chrome/browser/cocoa/chrome_browser_window.h"
 #import "chrome/browser/cocoa/browser_window_controller.h"
 #include "chrome/browser/global_keyboard_shortcuts_mac.h"
 #include "chrome/browser/cocoa/sad_tab_view.h"
 #import "chrome/browser/cocoa/web_drag_source.h"
 #import "chrome/browser/cocoa/web_drop_target.h"
 #include "chrome/browser/renderer_host/render_view_host_factory.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
@@ skipping 23 matching lines @@
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationDelete);
 COMPILE_ASSERT_MATCHING_ENUM(DragOperationEvery);
 
 @interface TabContentsViewCocoa (Private)
 - (id)initWithTabContentsViewMac:(TabContentsViewMac*)w;
 - (BOOL)processKeyboardEvent:(NativeWebKeyboardEvent*)event;
 - (void)registerDragTypes;
 - (void)setCurrentDragOperation:(NSDragOperation)operation;
 - (void)startDragWithDropData:(const WebDropData&)dropData
             dragOperationMask:(NSDragOperation)operationMask;
+- (void)cancelDeferredClose;
+- (void)closeTabAfterEvent;
 @end
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewMac(tab_contents);
 }
 
 TabContentsViewMac::TabContentsViewMac(TabContents* tab_contents)
     : TabContentsView(tab_contents) {
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
 }
 
+TabContentsViewMac::~TabContentsViewMac() {
+  // This handles the case where a renderer close call was deferred
+  // while the user was operating a UI control which resulted in a
+  // close.  In that case, the Cocoa view outlives the
+  // TabContentsViewMac instance due to Cocoa retain count.
+  [cocoa_view_ cancelDeferredClose];
+}
+
 void TabContentsViewMac::CreateView(const gfx::Size& initial_size) {
   TabContentsViewCocoa* view =
       [[TabContentsViewCocoa alloc] initWithTabContentsViewMac:this];
   cocoa_view_.reset(view);
 }
 
 RenderWidgetHostView* TabContentsViewMac::CreateViewForWidget(
     RenderWidgetHost* render_widget_host) {
   if (render_widget_host->view()) {
     // During testing, the view will already be set up in most cases to the
@@ skipping 171 matching lines @@
   TabContentsView::ShowCreatedWidgetInternal(widget_host_view, initial_pos);
 
   // A RenderWidgetHostViewMac has lifetime scoped to the view. Now that it's
   // properly embedded (or purposefully ignored) we can release the retain we
   // took in CreateNewWidgetInternal().
   RenderWidgetHostViewMac* widget_view_mac =
       static_cast<RenderWidgetHostViewMac*>(widget_host_view);
   [widget_view_mac->native_view() release];
 }
 
+bool TabContentsViewMac::IsEventTracking() const {
+  if ([NSApp isKindOfClass:[CrApplication class]] &&
+      [static_cast<CrApplication*>(NSApp) isHandlingSendEvent]) {
+    return true;
+  }
+  return false;
+}
+
+// Arrange to call CloseTab() after we're back to the main event loop.
+// The obvious way to do this would be PostNonNestableTask(), but that
+// will fire when the event-tracking loop polls for events.  So we
+// need to bounce the message via Cocoa, instead.
+void TabContentsViewMac::CloseTabAfterEventTracking() {
+  [cocoa_view_ cancelDeferredClose];
+  [cocoa_view_ performSelector:@selector(closeTabAfterEvent)
+                    withObject:nil
+                    afterDelay:0.0];
+}
+
+void TabContentsViewMac::CloseTab() {
+  tab_contents()->Close(tab_contents()->render_view_host());
+}
+
 void TabContentsViewMac::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::TAB_CONTENTS_CONNECTED: {
       if (sad_tab_.get()) {
         [sad_tab_.get() removeFromSuperview];
         sad_tab_.reset();
       }
       break;
@@ skipping 14 matching lines @@
   if (self != nil) {
     tabContentsView_ = w;
     dropTarget_.reset(
         [[WebDropTarget alloc] initWithTabContents:[self tabContents]]);
     [self registerDragTypes];
   }
   return self;
 }
 
 - (void)dealloc {
+  // Cancel any deferred tab closes, just in case.
+  [self cancelDeferredClose];
+
   // This probably isn't strictly necessary, but can't hurt.
   [self unregisterDraggedTypes];
   [super dealloc];
 }
 
 // Registers for the view for the appropriate drag types.
 // TODO(pinkerton): register for file drags.
 - (void)registerDragTypes {
   NSArray* types = [NSArray arrayWithObjects:NSStringPboardType,
       NSHTMLPboardType, NSURLPboardType, nil];
@@ skipping 165 matching lines @@
 }
 
 - (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender {
   return [dropTarget_ draggingUpdated:sender view:self];
 }
 
 - (BOOL)performDragOperation:(id<NSDraggingInfo>)sender {
   return [dropTarget_ performDragOperation:sender view:self];
 }
 
+- (void)cancelDeferredClose {
+  SEL aSel = @selector(closeTabAfterEvent);
+  [NSObject cancelPreviousPerformRequestsWithTarget:self
+                                           selector:aSel
+                                             object:nil];
+}
+
+- (void)closeTabAfterEvent {
+  tabContentsView_->CloseTab();
+}
+
 // Tons of stuff goes here, where we grab events going on in Cocoaland and send
 // them into the C++ system. TODO(avi): all that jazz
 
 @end