[MacViews] Enable dragging a window by its caption/draggable areas.

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 "base/logging.h"
+#import "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/thread_task_runner_handle.h"
 #import "ui/base/cocoa/constrained_window/constrained_window_animation.h"
+#include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/dip_util.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #import "ui/gfx/mac/nswindow_frame_controls.h"
 #include "ui/gfx/screen.h"
 #import "ui/views/cocoa/bridged_content_view.h"
 #import "ui/views/cocoa/cocoa_mouse_capture.h"
@@ skipping 16 matching lines @@
 @end
 
 @implementation ViewsCompositorSuperview
 - (NSView*)hitTest:(NSPoint)aPoint {
   return nil;
 }
 @end
 
 namespace {
 
+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,
+};
+
 int kWindowPropertiesKey;
 
 float GetDeviceScaleFactorFromView(NSView* view) {
   gfx::Display display =
       gfx::Screen::GetScreenFor(view)->GetDisplayNearestWindow(view);
   DCHECK(display.is_valid());
   return display.device_scale_factor();
 }
 
 // Returns true if bounds passed to window in SetBounds should be treated as
@@ skipping 11 matching lines @@
 gfx::Size GetClientSizeForWindowSize(NSWindow* window,
                                      const gfx::Size& window_size) {
   NSRect frame_rect =
       NSMakeRect(0, 0, window_size.width(), window_size.height());
   // Note gfx::Size will prevent dimensions going negative. They are allowed to
   // be zero at this point, because Widget::GetMinimumSize() may later increase
   // the size.
   return gfx::Size([window contentRectForFrameRect:frame_rect].size);
 }
 
+BOOL WindowWantsMouseDownReposted(NSEvent* ns_event) {
+  id delegate = [[ns_event window] delegate];
+  return
+      [delegate
+          respondsToSelector:@selector(shouldRepostPendingLeftMouseDown:)] &&
+      [delegate shouldRepostPendingLeftMouseDown:[ns_event locationInWindow]];
+}
+
+// Check if a mouse-down event should drag the window. If so, repost the event.
+NSEvent* RepostEventIfHandledByWindow(NSEvent* ns_event) {
+  // Which repost we're expecting to receive.
+  static RepostState repost_state = NONE;
+  // The event number of the reposted event. This let's us track whether an
+  // event is actually the repost since user-generated events have increasing
+  // event numbers. This is only valid while |repost_state != NONE|.
+  static NSInteger reposted_event_number;
+
+  CGEventRef cg_event = [ns_event CGEvent];
+  NSInteger event_number = [ns_event eventNumber];
+
+  // The logic here is a bit convoluted because we want to mitigate race
+  // conditions if somehow a different mouse-down occurs between reposts.
+  // Specifically, we want to avoid:
+  // - BridgedNativeWidget's draggability getting out of sync (e.g. if it is
+  //   draggable outside of a repost cycle),
+  // - any repost loop.
+
+  if (repost_state == NONE) {
+    // We're not in the middle of reposting, process this new event.
+    if (WindowWantsMouseDownReposted(ns_event)) {
+      repost_state = EXPECTING_REPOST;
+      reposted_event_number = [ns_event eventNumber];
+      CGEventPost(kCGSessionEventTap, cg_event);
+      return nil;
+    }
+
+    return ns_event;
+  }
+
+  if (repost_state == EXPECTING_REPOST) {
+    // Call through so that the window is made non-draggable again.
+    WindowWantsMouseDownReposted(ns_event);
+
+    if (reposted_event_number == event_number) {
+      // Reposted event received.
+      repost_state = NONE;
+      return nil;
+    }
+
+    // We were expecting a repost, but since this is a new mouse-down, cancel
+    // reposting and allow event to continue as usual.
+    repost_state = REPOST_CANCELLED;
+    return ns_event;
+  }
+
+  if (repost_state == REPOST_CANCELLED) {
+    if (reposted_event_number == event_number) {
+      // Reposting was cancelled, now that we've received the event, we don't
+      // expect to see it again.
+      repost_state = NONE;
+      return nil;
+    }
+
+    return ns_event;
+  }
+
+  NOTREACHED();
+  return ns_event;
+}
+
+// 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.
+void SetupDragEventMonitor() {
+  static id monitor = nil;
+  if (monitor)
+    return;
+
+  monitor = [NSEvent
+      addLocalMonitorForEventsMatchingMask:NSLeftMouseDownMask
+      handler:^NSEvent*(NSEvent* ns_event) {
+        return RepostEventIfHandledByWindow(ns_event);
+      }];
+}
+
 }  // namespace
 
 namespace views {
 
 // 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));
 }
 
 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();
   DCHECK(parent);
   window_delegate_.reset(
       [[ViewsNSWindowDelegate alloc] initWithBridgedNativeWidget:this]);
 }
 
 BridgedNativeWidget::~BridgedNativeWidget() {
   RemoveOrDestroyChildren();
   DCHECK(child_windows_.empty());
   SetFocusManager(NULL);
   SetRootView(NULL);
@@ skipping 427 matching lines @@
     if (is_key) {
       widget->OnNativeFocus();
       widget->GetFocusManager()->RestoreFocusedView();
     } else {
       widget->OnNativeBlur();
       widget->GetFocusManager()->StoreFocusedView(true);
     }
   }
 }
 
+bool BridgedNativeWidget::ShouldRepostPendingLeftMouseDown(
+    NSPoint location_in_window) {
+  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;
+  }
+
+  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;
+
+  // 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;
+    }
+  }
+
+  if (!should_move_window)
+    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
   // reset these after leaving fullscreen.
   if (target_fullscreen_state_ || in_fullscreen_transition_)
     return;
 
   Widget* widget = native_widget_mac()->GetWidget();
   gfx::Size min_size = widget->GetMinimumSize();
   gfx::Size max_size = widget->GetMaximumSize();
@@ skipping 318 matching lines @@
   NSMutableDictionary* properties = objc_getAssociatedObject(
       window_, &kWindowPropertiesKey);
   if (!properties) {
     properties = [NSMutableDictionary dictionary];
     objc_setAssociatedObject(window_, &kWindowPropertiesKey,
                              properties, OBJC_ASSOCIATION_RETAIN);
   }
   return properties;
 }
 
+void BridgedNativeWidget::SetDraggable(bool draggable) {
+  [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