mac: Move draggable region code to BrowserWindow

On macOS current draggable region implementation highly relies on
WebContents, the code is only meaningful for BrowserWindow.

atom/browser/api/atom_api_browser_window.cc

@@ -409,6 +409,10 @@ void BrowserWindow::OnWindowRestore() {
 }
 
 void BrowserWindow::OnWindowResize() {
+#if defined(OS_MACOSX)
+  if (!draggable_regions_.empty())
+    UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
   Emit("resize");
 }
 
@@ -1169,6 +1173,21 @@ void BrowserWindow::RemoveFromParentChildWindows() {
   parent->child_windows_.Remove(ID());
 }
 
+// Convert draggable regions in raw format to SkRegion format.
+std::unique_ptr<SkRegion> BrowserWindow::DraggableRegionsToSkRegion(
+    const std::vector<DraggableRegion>& regions) {
+  std::unique_ptr<SkRegion> sk_region(new SkRegion);
+  for (const DraggableRegion& region : regions) {
+    sk_region->op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+  return sk_region;
+}
+
 void BrowserWindow::ScheduleUnresponsiveEvent(int ms) {
   if (!window_unresponsive_closure_.IsCancelled())
     return;

atom/browser/api/atom_api_browser_window.h

@@ -261,6 +261,10 @@ class BrowserWindow : public mate::TrackableObject<BrowserWindow>,
       content::RenderFrameHost* rfh,
       const std::vector<DraggableRegion>& regions);
 
+  // Convert draggable regions in raw format to SkRegion format.
+  std::unique_ptr<SkRegion> DraggableRegionsToSkRegion(
+      const std::vector<DraggableRegion>& regions);
+
   // Schedule a notification unresponsive event.
   void ScheduleUnresponsiveEvent(int ms);
 
@@ -272,6 +276,10 @@ class BrowserWindow : public mate::TrackableObject<BrowserWindow>,
   MessageCallbackMap messages_callback_map_;
 #endif
 
+#if defined(OS_MACOSX)
+  std::vector<DraggableRegion> draggable_regions_;
+#endif
+
   // Closure that would be called when window is unresponsive when closing,
   // it should be cancelled when we can prove that the window is responsive.
   base::CancelableClosure window_unresponsive_closure_;

atom/browser/api/atom_api_browser_window_mac.mm

@@ -6,24 +6,115 @@
 
 #import <Cocoa/Cocoa.h>
 
+#include "atom/browser/native_browser_view_mac.h"
+#include "atom/browser/native_window_mac.h"
+#include "atom/common/draggable_region.h"
+#include "base/mac/scoped_nsobject.h"
+
 @interface NSView (WebContentsView)
 - (void)setMouseDownCanMoveWindow:(BOOL)can_move;
 @end
 
+@interface ControlRegionView : NSView
+@end
+
+@implementation ControlRegionView
+
+- (BOOL)mouseDownCanMoveWindow {
+  return NO;
+}
+
+- (NSView*)hitTest:(NSPoint)aPoint {
+  return nil;
+}
+
+@end
+
 namespace atom {
 
 namespace api {
 
+namespace {
+
+// Return a vector of non-draggable regions that fill a window of size
+// |width| by |height|, but leave gaps where the window should be draggable.
+std::vector<gfx::Rect> CalculateNonDraggableRegions(
+    std::unique_ptr<SkRegion> draggable, int width, int height) {
+  std::vector<gfx::Rect> result;
+  std::unique_ptr<SkRegion> non_draggable(new SkRegion);
+  non_draggable->op(0, 0, width, height, SkRegion::kUnion_Op);
+  non_draggable->op(*draggable, SkRegion::kDifference_Op);
+  for (SkRegion::Iterator it(*non_draggable); !it.done(); it.next()) {
+    result.push_back(gfx::SkIRectToRect(it.rect()));
+  }
+  return result;
+}
+
+}  // namespace
+
 void BrowserWindow::UpdateDraggableRegions(
     content::RenderFrameHost* rfh,
     const std::vector<DraggableRegion>& regions) {
   if (window_->has_frame())
     return;
+
+  // All ControlRegionViews should be added as children of the WebContentsView,
+  // because WebContentsView will be removed and re-added when entering and
+  // leaving fullscreen mode.
   NSView* webView = web_contents()->GetNativeView();
+  NSInteger webViewWidth = NSWidth([webView bounds]);
+  NSInteger webViewHeight = NSHeight([webView bounds]);
+
   if ([webView respondsToSelector:@selector(setMouseDownCanMoveWindow:)]) {
     [webView setMouseDownCanMoveWindow:YES];
   }
-  window_->UpdateDraggableRegions(regions);
+
+  // Remove all ControlRegionViews that are added last time.
+  // Note that [webView subviews] returns the view's mutable internal array and
+  // it should be copied to avoid mutating the original array while enumerating
+  // it.
+  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
+  for (NSView* subview in subviews.get())
+    if ([subview isKindOfClass:[ControlRegionView class]])
+      [subview removeFromSuperview];
+
+  // Draggable regions is implemented by having the whole web view draggable
+  // (mouseDownCanMoveWindow) and overlaying regions that are not draggable.
+  draggable_regions_ = regions;
+  std::vector<gfx::Rect> system_drag_exclude_areas;
+  if (regions.empty()) {
+    system_drag_exclude_areas.push_back(
+        gfx::Rect(0, 0, webViewWidth, webViewHeight));
+  } else {
+    CalculateNonDraggableRegions(
+        DraggableRegionsToSkRegion(regions), webViewWidth, webViewHeight);
+  }
+
+  NativeWindowMac* window = static_cast<NativeWindowMac*>(window_.get());
+  if (window->browser_view())
+    window->browser_view()->UpdateDraggableRegions(system_drag_exclude_areas);
+
+  // Create and add a ControlRegionView for each region that needs to be
+  // excluded from the dragging.
+  for (std::vector<gfx::Rect>::const_iterator iter =
+           system_drag_exclude_areas.begin();
+       iter != system_drag_exclude_areas.end();
+       ++iter) {
+    base::scoped_nsobject<NSView> controlRegion(
+        [[ControlRegionView alloc] initWithFrame:NSZeroRect]);
+    [controlRegion setFrame:NSMakeRect(iter->x(),
+                                       webViewHeight - iter->bottom(),
+                                       iter->width(),
+                                       iter->height())];
+    [webView addSubview:controlRegion];
+  }
+
+  // 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.
+  [[webView window] setMovableByWindowBackground:NO];
+  [[webView window] setMovableByWindowBackground:YES];
 }
 
 }  // namespace api

atom/browser/api/atom_api_browser_window_views.cc

@@ -11,7 +11,9 @@ namespace api {
 void BrowserWindow::UpdateDraggableRegions(
     content::RenderFrameHost* rfh,
     const std::vector<DraggableRegion>& regions) {
-  window_->UpdateDraggableRegions(regions);
+  if (window_->has_frame())
+    return;
+  window_->UpdateDraggableRegions(DraggableRegionsToSkRegion(regions));
 }
 
 }  // namespace api