MacViews: Fix window dragging on Sierra.

ui/views/cocoa/bridged_native_widget.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 "ui/views/cocoa/bridged_native_widget.h"
 
 #import <objc/runtime.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 151 matching lines @@
   if (can_resize_x && can_resize_y &&
       (point.x < kResizeAreaCornerSize ||
        point.x >= window_size.width - kResizeAreaCornerSize) &&
       (point.y < kResizeAreaCornerSize ||
        point.y >= window_size.height - kResizeAreaCornerSize))
     return true;
 
   return false;
 }
 
+// Routes the |ns_event| to the corresponding BridgedNativeWidget and queries
+// whether the event should be reposted.
 BOOL WindowWantsMouseDownReposted(NSEvent* ns_event) {
-  id delegate = [[ns_event window] delegate];
-  return
-      [delegate
-          respondsToSelector:@selector(shouldRepostPendingLeftMouseDown:)] &&
-      [delegate shouldRepostPendingLeftMouseDown:[ns_event locationInWindow]];
+  DCHECK(views::BridgedNativeWidget::ShouldUseDragEventMonitor());
+
+  views::BridgedNativeWidget* bridge =
+      views::NativeWidgetMac::GetBridgeForNativeWindow([ns_event window]);
+  return bridge && bridge->ShouldRepostPendingLeftMouseDown(ns_event);
 }
 
 // Check if a mouse-down event should drag the window. If so, repost the event.
 NSEvent* RepostEventIfHandledByWindow(NSEvent* ns_event) {
+  DCHECK(views::BridgedNativeWidget::ShouldUseDragEventMonitor());
+
   enum RepostState {
     // Nothing reposted: hit-test new mouse-downs to see if they need to be
     // ignored and reposted after changing draggability.
     NONE,
     // Expecting the next event to be the reposted event: let it go through.
     EXPECTING_REPOST,
     // If, while reposting, another mousedown was received: when the reposted
     // event is seen, ignore it.
     REPOST_CANCELLED,
   };
@@ skipping 54 matching lines @@
 
 // Support window caption/draggable regions.
 // In AppKit, non-client regions are set by overriding
 // -[NSView mouseDownCanMoveWindow]. NSApplication caches this area as views are
 // installed and performs window moving when mouse-downs land in the area.
 // In Views, non-client regions are determined via hit-tests when the event
 // occurs.
 // To bridge the two models, we monitor mouse-downs with
 // +[NSEvent addLocalMonitorForEventsMatchingMask:handler:]. This receives
 // events after window dragging is handled, so for mouse-downs that land on a
-// draggable point, we cancel the event and repost it at the CGSessionEventTap
-// level so that window dragging will be handled again.
+// draggable point, we cancel the event, make the window draggable and repost it
+// at the CGSessionEventTap level so that window dragging will be handled again.
+// On Mac OS > 10.10, we don't use an event monitor. Instead, we use [NSWindow
+// performWindowDragWithEvent:]. See [NativeWidgetMacNSWindow sendEvent:].
 void SetupDragEventMonitor() {
+  DCHECK(views::BridgedNativeWidget::ShouldUseDragEventMonitor());
   static id monitor = nil;
   if (monitor)
     return;
 
   monitor = [NSEvent
       addLocalMonitorForEventsMatchingMask:NSLeftMouseDownMask
       handler:^NSEvent*(NSEvent* ns_event) {
         return RepostEventIfHandledByWindow(ns_event);
       }];
 }
@@ skipping 62 matching lines @@
 // static
 gfx::Size BridgedNativeWidget::GetWindowSizeForClientSize(
     NSWindow* window,
     const gfx::Size& content_size) {
   NSRect content_rect =
       NSMakeRect(0, 0, content_size.width(), content_size.height());
   NSRect frame_rect = [window frameRectForContentRect:content_rect];
   return gfx::Size(NSWidth(frame_rect), NSHeight(frame_rect));
 }
 
+// static
+// TODO(karandeepb): Remove usage of drag event monitor once we stop supporting
+// Mac OS 10.10.
+bool BridgedNativeWidget::ShouldUseDragEventMonitor() {
+  return ![NSWindow
+      instancesRespondToSelector:@selector(performWindowDragWithEvent:)];
+}
+
 BridgedNativeWidget::BridgedNativeWidget(NativeWidgetMac* parent)
     : native_widget_mac_(parent),
       focus_manager_(nullptr),
       widget_type_(Widget::InitParams::TYPE_WINDOW),  // Updated in Init().
       parent_(nullptr),
       target_fullscreen_state_(false),
       in_fullscreen_transition_(false),
       window_visible_(false),
       wants_to_be_visible_(false) {
-  SetupDragEventMonitor();
+  if (BridgedNativeWidget::ShouldUseDragEventMonitor())
+    SetupDragEventMonitor();
+
   DCHECK(parent);
   window_delegate_.reset(
       [[ViewsNSWindowDelegate alloc] initWithBridgedNativeWidget:this]);
 }
 
 BridgedNativeWidget::~BridgedNativeWidget() {
   // The delegate should be cleared already. Note this enforces the precondition
   // that -[NSWindow close] is invoked on the hosted window before the
   // destructor is called.
   DCHECK(![window_ delegate]);
@@ skipping 193 matching lines @@
 
   if (native_widget_mac_->IsWindowModalSheet()) {
     ShowAsModalSheet();
     return;
   }
 
   // Non-modal windows are not animated. Hence opaque non-modal windows can
   // appear with a "flash" if they are made visible before the frame from the
   // compositor arrives. To get around this, set the alpha value of the window
   // to 0, till we receive the correct frame from the compositor. Also, ignore
-  // mouse clicks till then.
+  // mouse clicks till then. Also check for an active task runner on the
+  // WindowResizeHelperMac instance to ensure visibility is only suppressed when
+  // there is an active GPU process.
   // TODO(karandeepb): Investigate whether similar technique is needed for other
   // dialog types.
   if (layer() && [window_ isOpaque] && !window_visible_ &&
-      !native_widget_mac_->GetWidget()->IsModal()) {
+      !native_widget_mac_->GetWidget()->IsModal() &&
+      ui::WindowResizeHelperMac::Get()->task_runner()) {
     initial_visibility_suppressed_ = true;
     [window_ setAlphaValue:0.0];
     [window_ setIgnoresMouseEvents:YES];
   }
 
   if (new_state == SHOW_AND_ACTIVATE_WINDOW) {
     [window_ makeKeyAndOrderFront:nil];
     [NSApp activateIgnoringOtherApps:YES];
   } else {
     // ui::SHOW_STATE_INACTIVE is typically used to avoid stealing focus from a
@@ skipping 290 matching lines @@
       // window status.
       [bridged_view_ updateFullKeyboardAccess];
       widget->GetFocusManager()->RestoreFocusedView();
     } else {
       widget->OnNativeBlur();
       widget->GetFocusManager()->StoreFocusedView(true);
     }
   }
 }
 
-bool BridgedNativeWidget::ShouldRepostPendingLeftMouseDown(
-    NSPoint location_in_window) {
-  if (!bridged_view_)
+bool BridgedNativeWidget::ShouldDragWindow(NSEvent* event) {
+  if (!bridged_view_ || [event type] != NSLeftMouseDown)
     return false;
 
-  if ([bridged_view_ mouseDownCanMoveWindow]) {
-    // This is a re-post, the movement has already started, so we can make the
-    // window non-draggable again.
-    SetDraggable(false);
-    return false;
-  }
-
+  NSPoint location_in_window = [event locationInWindow];
   if (IsPointInResizeArea(location_in_window, window_))
     return false;
 
   gfx::Point point(location_in_window.x,
                    NSHeight([window_ frame]) - location_in_window.y);
-  bool should_move_window =
-      native_widget_mac()->GetWidget()->GetNonClientComponent(point) ==
-      HTCAPTION;
+
+  if (native_widget_mac()->GetWidget()->GetNonClientComponent(point) !=
+      HTCAPTION)
+    return false;
 
   // Check that the point is not obscured by non-content NSViews.
   for (NSView* subview : [[bridged_view_ superview] subviews]) {
     if (subview == bridged_view_.get())
       continue;
 
     if (![subview mouseDownCanMoveWindow] &&
-        NSPointInRect(location_in_window, [subview frame])) {
-      should_move_window = false;
-      break;
-    }
+        NSPointInRect(location_in_window, [subview frame]))
+      return false;
   }
 
-  if (!should_move_window)
+  return true;
+}
+
+bool BridgedNativeWidget::ShouldRepostPendingLeftMouseDown(NSEvent* event) {
+  DCHECK(BridgedNativeWidget::ShouldUseDragEventMonitor());
+  DCHECK_EQ(NSLeftMouseDown, [event type]);
+
+  if (!bridged_view_)
+    return false;
+
+  if ([bridged_view_ mouseDownCanMoveWindow]) {
+    // This is a re-post, the movement has already started, so we can make the
+    // window non-draggable again.
+    SetDraggable(false);
+    return false;
+  }
+
+  if (!ShouldDragWindow(event))
     return false;
 
   // Make the window draggable, then return true to repost the event.
   SetDraggable(true);
   return true;
 }
 
 void BridgedNativeWidget::OnSizeConstraintsChanged() {
   // Don't modify the size constraints or fullscreen collection behavior while
   // in fullscreen or during a transition. OnFullscreenTransitionComplete will
@@ skipping 445 matching lines @@
       window_, &kWindowPropertiesKey);
   if (!properties) {
     properties = [NSMutableDictionary dictionary];
     objc_setAssociatedObject(window_, &kWindowPropertiesKey,
                              properties, OBJC_ASSOCIATION_RETAIN);
   }
   return properties;
 }
 
 void BridgedNativeWidget::SetDraggable(bool draggable) {
+  DCHECK(BridgedNativeWidget::ShouldUseDragEventMonitor());
+
   [bridged_view_ setMouseDownCanMoveWindow:draggable];
   // AppKit will not update its cache of mouseDownCanMoveWindow unless something
   // changes. Previously we tried adding an NSView and removing it, but for some
   // reason it required reposting the mouse-down event, and didn't always work.
   // Calling the below seems to be an effective solution.
   [window_ setMovableByWindowBackground:NO];
   [window_ setMovableByWindowBackground:YES];
 }
 
 }  // namespace views