MacViews: Implement Tab Dragging

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>
 
 #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/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.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/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"
 #include "ui/views/cocoa/tooltip_manager_mac.h"
 #import "ui/views/cocoa/views_nswindow_delegate.h"
 #import "ui/views/cocoa/widget_owner_nswindow_adapter.h"
 #include "ui/views/view.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_mac.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 
-extern "C" {
-
-typedef int32_t CGSConnection;
-CGSConnection _CGSDefaultConnection();
-CGError CGSSetWindowBackgroundBlurRadius(CGSConnection connection,
-                                         NSInteger windowNumber,
-                                         int radius);
-
-}
-
 // The NSView that hosts the composited CALayer drawing the UI. It fills the
 // window but is not hittable so that accessibility hit tests always go to the
 // BridgedContentView.
 @interface ViewsCompositorSuperview : NSView
 @end
 
 @implementation ViewsCompositorSuperview
 - (NSView*)hitTest:(NSPoint)aPoint {
   return nil;
 }
@@ skipping 29 matching lines @@
 const CGFloat kYosemiteMenuOpacity = 194.0 / 255.0;
 const int kYosemiteMenuBlur = 80;
 
 // Margin at edge and corners of the window that trigger resizing. These match
 // actual Cocoa resize margins.
 const int kResizeAreaEdgeSize = 3;
 const int kResizeAreaCornerSize = 12;
 
 int kWindowPropertiesKey;
 
+bool g_ignore_next_mouse_down_for_draggable_regions = false;
+
 float GetDeviceScaleFactorFromView(NSView* view) {
   gfx::Display display =
       gfx::Screen::GetScreen()->GetDisplayNearestWindow(view);
   DCHECK(display.is_valid());
   return display.device_scale_factor();
 }
 
 // Returns true if bounds passed to window in SetBounds should be treated as
 // though they are in screen coordinates.
 bool PositionWindowInScreenCoordinates(views::Widget* widget,
@@ skipping 77 matching lines @@
   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) {
+    if (g_ignore_next_mouse_down_for_draggable_regions) {
+      g_ignore_next_mouse_down_for_draggable_regions = false;
+      return ns_event;
+    }
+
     if (WindowWantsMouseDownReposted(ns_event)) {
       repost_state = EXPECTING_REPOST;
       reposted_event_number = event_number;
       CGEventPost(kCGSessionEventTap, [ns_event CGEvent]);
       return nil;
     }
 
     return ns_event;
   }
 
@@ skipping 52 matching lines @@
 // resize operations to coordinate with frames provided by the GPU process.
 scoped_refptr<base::SingleThreadTaskRunner> GetCompositorTaskRunner() {
   // If the WindowResizeHelper's pumpable task runner is set, it means the GPU
   // process is directing messages there, and the compositor can synchronize
   // with it. Otherwise, just use the UI thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       ui::WindowResizeHelperMac::Get()->task_runner();
   return task_runner ? task_runner : base::ThreadTaskRunnerHandle::Get();
 }
 
+CGPoint GetCGMousePosition() {
+  return CGEventGetLocation(
+      base::ScopedCFTypeRef<CGEventRef>(CGEventCreate(nullptr)));
+}
+
+void SendCustomLeftMouseEvent(CGEventType type) {
+  base::ScopedCFTypeRef<CGEventRef> event(
+                  CGEventCreateMouseEvent(
+                      nullptr, type, GetCGMousePosition(),
+                      kCGMouseButtonLeft));
+  CGEventSetIntegerValueField(event, kCGEventSourceUserData, 1);
+  CGEventPost(kCGSessionEventTap, event);
+}
+
 }  // namespace
 
+extern "C" {
+
+typedef int32_t CGSConnection;
+CGSConnection _CGSDefaultConnection();
+CGError CGSSetWindowBackgroundBlurRadius(CGSConnection connection,
+                                         NSInteger windowNumber,
+                                         int radius);
+
+}
+
+// CocoaWindowMoveLoop can be deleted just before its local event monitor is
+// processed and in that case it's too late to call removeMonitor: and we have a
+// dangling this pointer. Use a proxy Obj-C class to store the weakptr.
+@interface WeakCocoaWindowMoveLoop : NSObject {
+ @private
+  base::WeakPtr<views::CocoaWindowMoveLoop> weak_;
+}
+@end
+
+@implementation WeakCocoaWindowMoveLoop
+- (id)initWithWeakPtr:(const base::WeakPtr<views::CocoaWindowMoveLoop>&)weak {
+  if (self = [super init]) {
+    weak_ = weak;
+  }
+  return self;
+}
+
+- (base::WeakPtr<views::CocoaWindowMoveLoop>&)weak {
+  return weak_;
+}
+@end
+
 namespace views {
 
+class CocoaWindowMoveLoop {

[tapted, 2016/03/10 11:51:19]

Move this to its own file (with WeakCocoaMoveLoop?) -
ui/views/cocoa/cocoa_window_move_loop.{h,mm}. I think this grew in line count
unexpectedly while experimenting..

[themblsha, 2016/03/10 17:18:58]

Oh, right, you told me about that and it seems that I forgot when reviewing the
earlier comments. Sorry, should be fixed now!

+ public:
+  explicit CocoaWindowMoveLoop(BridgedNativeWidget* owner)
+      : owner_(owner),
+        run_loop_(new base::RunLoop),
+        quit_closure_(run_loop_->QuitClosure()),
+        weak_factory_(this) {
+    // AppKit continues to send mouse events to the window, but toolkit-views
+    // goes berserk if it gets them during RunMoveLoop().

[tapted, 2016/03/10 11:51:19]

hehe - I remember writing `berserk`... Perhaps "but toolkit-views doesn't expect
them during RunMoveLoop()."

[themblsha, 2016/03/10 17:18:58]

Done.

+    [owner_->ns_view() setIgnoreMouseEvents:YES];
+    owner_->SetDraggable(true);
+  }
+
+  ~CocoaWindowMoveLoop() {
+    owner_->SetDraggable(false);
+    // Note the crafted events in Run() should not make their way through to
+    // toolkit-views, but regular events after that should be. So stop ignoring.
+    [owner_->ns_view() setIgnoreMouseEvents:NO];
+
+    // Handle the pathological case, where |this| is destroyed while running.
+    if (exit_reason_ref_) {
+      *exit_reason_ref_ = WINDOW_DESTROYED;
+      quit_closure_.Run();
+    }
+
+    // Handle Run() never being called.
+    if (monitor_) {
+      [NSEvent removeMonitor:monitor_];
+      monitor_ = nil;
+    }
+    owner_ = nullptr;
+  }
+
+  Widget::MoveLoopResult Run() {
+    LoopExitReason exit_reason = ENDED_EXTERNALLY;
+    exit_reason_ref_ = &exit_reason;
+
+    // Move the RunLoop to the stack so our destructor can be called while it is
+    // running.
+    scoped_ptr<base::RunLoop> run_loop(std::move(run_loop_));
+
+    // A new window may have just been created, so post an event at the session
+    // tap level to initiate a window drag.
+    // TODO(tapted): Move this "inside" the window or stuff breaks when dragging
+    // the last tab/s off a browser.
+    SendCustomLeftMouseEvent(kCGEventLeftMouseDown);
+
+    WeakCocoaWindowMoveLoop* proxy_quit_closure =
+        [[[WeakCocoaWindowMoveLoop alloc]
+            initWithWeakPtr:weak_factory_.GetWeakPtr()] autorelease];
+
+    NSEventMask mask =
+        NSLeftMouseUpMask | NSKeyDownMask | NSLeftMouseDraggedMask;
+    monitor_ = [NSEvent addLocalMonitorForEventsMatchingMask:mask
+        handler:^NSEvent*(NSEvent* event) {
+          if ([event type] == NSLeftMouseDragged) {
+            // AppKit doesn't supply position updates during a drag, so post a
+            // task to notify observers once AppKit has moved the window.
+            base::MessageLoop::current()->PostTask(
+                FROM_HERE, base::Bind(&BridgedNativeWidget::OnPositionChanged,
+                                      base::Unretained(owner_)));
+            return event;
+          }
+
+          CocoaWindowMoveLoop* thiss = [proxy_quit_closure weak].get();
+          if (!thiss)
+            return nil;
+
+          thiss->quit_closure_.Run();
+          if ([event type] == NSLeftMouseUp) {
+            *thiss->exit_reason_ref_ = MOUSE_UP;
+            return event;  // Process the MouseUp.
+          }
+          *thiss->exit_reason_ref_ = ESCAPE_PRESSED;
+          return nil;  // Swallow the keypress.
+        }];
+
+    // NSKeyDownMask doesn't work inside addLocalMonitorForEventsMatchingMask:
+    // the event is swallowed by the window move loop before it gets to -[NSApp
+    // sendEvent:]. To see an escape keypress, hook in an event tap lower.
+
+    run_loop->Run();
+
+    if (exit_reason != WINDOW_DESTROYED && exit_reason != ENDED_EXTERNALLY) {
+      exit_reason_ref_ = nullptr;  // Ensure End() doesn't replace the reason.
+      owner_->EndMoveLoop();  // Deletes |this|.
+    }
+
+    if (exit_reason != MOUSE_UP) {
+      // Tell AppKit to stop moving the window. Otherwise, AppKit will refuse to
+      // start a new window drag. Note the window being dragged is going away in
+      // this case, so it doesn't really matter where the event is located.
+      SendCustomLeftMouseEvent(kCGEventLeftMouseUp);
+
+      if (exit_reason == ENDED_EXTERNALLY) {
+        // When not canceled, the non-moving drag in the original window must
+        // resume. To do this, AppKit needs to see a mouseDown so that it sends
+        // the correct events. Ideally, it also needs to be at the original
+        // offset, so that it hits a non-draggable region of the original
+        // window: The tab being dragged may move some distance from the cursor
+        // when it "snaps in", so the cursor may not be over a tab. Sadly, this
+        // method doesn't know which window that is. But all that really needs
+        // to be done is to prevent a custom-dragging area from starting a
+        // window-drag. So hook into the logic in RepostEventIfHandledByWindow()
+        // by setting a flag here. Note this assumes the custom mouseDown event
+        // is guaranteed to hit another BridgedNativeWidget when it gets to the
+        // front of the event queue.
+        // TODO(tapted): A better fix would be to keep the temporary window
+        // around and never call EndMoveLoop() on Mac, making this block of code
+        // obsolete.
+        g_ignore_next_mouse_down_for_draggable_regions = true;
+        SendCustomLeftMouseEvent(kCGEventLeftMouseDown);
+      }
+    }
+
+    return exit_reason == ESCAPE_PRESSED
+        ? Widget::MOVE_LOOP_CANCELED : Widget::MOVE_LOOP_SUCCESSFUL;
+  }
+
+  void End() {
+    if (exit_reason_ref_) {
+      DCHECK_EQ(*exit_reason_ref_, ENDED_EXTERNALLY);
+      // Ensure the destructor doesn't replace the reason.
+      exit_reason_ref_ = nullptr;
+      quit_closure_.Run();
+    }
+  }
+
+  static CGEventRef EscapeKeypressMonitor(CGEventTapProxy proxy,
+                                          CGEventType type,
+                                          CGEventRef event,
+                                          void* refcon) {
+    CocoaWindowMoveLoop* self = static_cast<CocoaWindowMoveLoop*>(refcon);
+    (void)self;
+    return event;
+  }
+
+ private:
+  enum LoopExitReason {
+    ENDED_EXTERNALLY,
+    ESCAPE_PRESSED,
+    MOUSE_UP,
+    WINDOW_DESTROYED,
+  };
+
+  BridgedNativeWidget* owner_;  // Weak. Owns this.
+  scoped_ptr<base::RunLoop> run_loop_;
+  id monitor_ = nil;
+
+  // Pointer to a stack variable holding the exit reason.
+  LoopExitReason* exit_reason_ref_ = nullptr;
+  base::Closure quit_closure_;
+
+  // WeakPtrFactory for event monitor safety.
+  base::WeakPtrFactory<CocoaWindowMoveLoop> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CocoaWindowMoveLoop);
+};
+
 // 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));
 }
 
@@ skipping 282 matching lines @@
 }
 
 void BridgedNativeWidget::ReleaseCapture() {
   mouse_capture_.reset();
 }
 
 bool BridgedNativeWidget::HasCapture() {
   return mouse_capture_ && mouse_capture_->IsActive();
 }
 
+Widget::MoveLoopResult BridgedNativeWidget::RunMoveLoop(
+      const gfx::Vector2d& drag_offset) {
+  DCHECK(!HasCapture());
+  DCHECK(!window_move_loop_);
+
+  // First, position the window in the right place. The point |drag_offset|
+  // away from the top-left corner needs to be positioned under the mouse.
+  // TODO(tapted): Figure out why the toolkit-views drag controller doesn't get
+  // this right when it first initializes the Widget.
+  NSPoint mouse_in_screen = gfx::ScreenPointToNSPoint(
+      gfx::Screen::GetScreen()->GetCursorScreenPoint());
+  NSRect frame = [window_ frame];
+  frame.origin.x = mouse_in_screen.x - drag_offset.x();
+  frame.origin.y = mouse_in_screen.y - NSHeight(frame) + drag_offset.y();
+
+  // After setting the frame to correct the initial offset, the drag controller
+  // may immediately want to quit when it's notified of the new bounds. So the
+  // MoveLoop must be set up before the call to setFrame.
+  window_move_loop_.reset(new CocoaWindowMoveLoop(this));
+
+  // Animating may provide a less janky UX, but something custom would be
+  // required so that it follows updates to the mouse position.
+  [window_ setFrame:frame display:YES animate:NO];
+
+  // Setting the frame will call OnWidgetBoundsChanged(), which could result in
+  // a call to EndMoveLoop().
+  if (!window_move_loop_)
+    return Widget::MOVE_LOOP_SUCCESSFUL;
+
+  return window_move_loop_->Run();
+
+  // |this| may be destroyed during the RunLoop, causing it to exit early.
+  // Even if that doesn't happen, CocoaWindowMoveLoop will clean itself up by
+  // calling EndMoveLoop(). So window_move_loop_ will always be null before the
+  // function returns. But don't DCHECK since |this| might not be valid.
+}
+
+void BridgedNativeWidget::EndMoveLoop() {
+  DCHECK(window_move_loop_);
+  window_move_loop_->End();
+  window_move_loop_.reset();
+}
+
 void BridgedNativeWidget::SetNativeWindowProperty(const char* name,
                                                   void* value) {
   NSString* key = [NSString stringWithUTF8String:name];
   if (value) {
     [GetWindowProperties() setObject:[NSValue valueWithPointer:value]
                               forKey:key];
   } else {
     [GetWindowProperties() removeObjectForKey:key];
   }
 }
 
 void* BridgedNativeWidget::GetNativeWindowProperty(const char* name) const {
   NSString* key = [NSString stringWithUTF8String:name];
   return [[GetWindowProperties() objectForKey:key] pointerValue];
 }
 
 void BridgedNativeWidget::SetCursor(NSCursor* cursor) {
   [window_delegate_ setCursor:cursor];
 }
 
 void BridgedNativeWidget::OnWindowWillClose() {
+  DCHECK(!drag_run_loop_);
   if (parent_) {
     parent_->RemoveChildWindow(this);
     parent_ = nullptr;
   }
   [window_ setDelegate:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:window_delegate_];
   native_widget_mac_->OnWindowWillClose();
 }
 
 void BridgedNativeWidget::OnFullscreenTransitionStart(
@@ skipping 82 matching lines @@
 
   // 10.9 is unable to generate a window shadow from the composited CALayer, so
   // use Quartz.
   // We don't update the window mask during a live resize, instead it is done
   // after the resize is completed in viewDidEndLiveResize: in
   // BridgedContentView.
   if (base::mac::IsOSMavericksOrEarlier() && ![window_ inLiveResize])
     [bridged_view_ updateWindowMask];
 }
 
+void BridgedNativeWidget::OnPositionChanged() {
+  native_widget_mac_->GetWidget()->OnNativeWidgetMove();
+}
+
 void BridgedNativeWidget::OnVisibilityChanged() {
   OnVisibilityChangedTo([window_ isVisible]);
 }
 
 void BridgedNativeWidget::OnVisibilityChangedTo(bool new_visibility) {
   if (window_visible_ == new_visibility)
     return;
 
   window_visible_ = new_visibility;
 
@@ skipping 533 matching lines @@
   [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