MacViews: Implement capture using NSEvent local+global monitors

ui/views/cocoa/cocoa_mouse_capture_unittest.mm

Index: ui/views/cocoa/cocoa_mouse_capture_unittest.mm
diff --git a/ui/views/cocoa/cocoa_mouse_capture_unittest.mm b/ui/views/cocoa/cocoa_mouse_capture_unittest.mm
new file mode 100644
index 0000000000000000000000000000000000000000..911efad428f4968a0e4d4f63368ea21a9fd22ccf
--- /dev/null
+++ b/ui/views/cocoa/cocoa_mouse_capture_unittest.mm
@@ -0,0 +1,127 @@
+// 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/cocoa_mouse_capture.h"
+
+#import <Cocoa/Cocoa.h>
+
+#import "base/mac/scoped_nsobject.h"
+#import "ui/events/test/cocoa_test_event_utils.h"
+#import "ui/gfx/test/ui_cocoa_test_helper.h"
+#import "ui/views/cocoa/cocoa_mouse_capture_delegate.h"
+
+// Simple test view that counts calls to -[NSView mouseDown:].
+@interface CocoaMouseCaptureTestView : NSView {
+ @private
+  int mouseDownCount_;

[Andre, 2014/12/12 22:57:38]

Objective-C style guide says that underscore should be in front, but ok for
existing projects to keep using underscore at the end. 
http://google-styleguide.googlecode.com/svn/trunk/objcguide.xml?showone=Varia...
Chrome Mac is now 64-bits only (except for some bots that haven't been
updated), so we can soon start using modern ObjC features such as
auto-synthesis of ivars and accessors.
Putting underscores in front would make that transition easier, but at
the expense of inconsistency with the rest of the project.
Either way is OK with me, just wanted to bring it up.
See
http://useyourloaf.com/blog/2012/08/01/property-synthesis-with-xcode-4-dot-4....

[tapted, 2014/12/17 03:20:51]

Ooh - interesting. TBH, I think there is so much more C++ code in Chrome that
moving the underscore to the front will be a hard sell, even though they're in
camelCase as well. A leading underscore is still likely to make someone freak
out with a "that's reserved for the compiler/libraries" reaction (which used to
be true, but is mostly historical now - particularly for code only compiled for
Apple stuff - like that article points out)

+}
+@property(readonly, nonatomic) int mouseDownCount;
+@end
+
+@implementation CocoaMouseCaptureTestView
+
+@synthesize mouseDownCount = mouseDownCount_;
+
+- (void)mouseDown:(NSEvent*)theEvent {
+  ++mouseDownCount_;
+}
+
+@end
+
+namespace views {
+namespace {
+
+// Simple capture delegate that just counts events forwarded.
+class TestCaptureDelegate : public CocoaMouseCaptureDelegate {
+ public:
+  TestCaptureDelegate() : event_count_(0), capture_lost_count_(0) {}
+
+  void Acquire() { mouse_capture_.reset(new CocoaMouseCapture(this)); }
+  bool IsActive() { return mouse_capture_ && mouse_capture_->IsActive(); }
+  void SimulateDestroy() { mouse_capture_.reset(); }
+
+  int event_count() { return event_count_; }
+  int capture_lost_count() { return capture_lost_count_; }
+
+  // CocoaMouseCaptureDelegate:
+  void PostCapturedEvent(NSEvent* event) override { ++event_count_; }
+  void OnMouseCaptureLost() override { ++capture_lost_count_; }
+
+ private:
+  scoped_ptr<CocoaMouseCapture> mouse_capture_;
+  int event_count_;
+  int capture_lost_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestCaptureDelegate);
+};
+
+}  // namespace
+
+typedef ui::CocoaTest CocoaMouseCaptureTest;
+
+// Test that a new capture properly "steals" capture from an existing one.
+TEST_F(CocoaMouseCaptureTest, OnCaptureLost) {
+  TestCaptureDelegate capture;
+
+  capture.Acquire();
+  EXPECT_TRUE(capture.IsActive());
+  {
+    TestCaptureDelegate capture2;
+    EXPECT_EQ(0, capture.capture_lost_count());
+
+    // A second capture steals from the first.
+    capture2.Acquire();
+    EXPECT_TRUE(capture2.IsActive());
+    EXPECT_FALSE(capture.IsActive());
+    EXPECT_EQ(1, capture.capture_lost_count());
+    EXPECT_EQ(0, capture2.capture_lost_count());
+
+    // Simulate capture2 going out of scope. Inspect it.
+    capture2.SimulateDestroy();
+    EXPECT_FALSE(capture2.IsActive());
+    EXPECT_EQ(1, capture2.capture_lost_count());
+  }
+
+  // Re-acquiring is fine (not stealing).
+  EXPECT_FALSE(capture.IsActive());
+  capture.Acquire();
+  EXPECT_TRUE(capture.IsActive());
+
+  // Having no CocoaMouseCapture instance is fine.
+  capture.SimulateDestroy();
+  EXPECT_FALSE(capture.IsActive());
+  // Receives OnMouseCaptureLost again, since reacquired.
+  EXPECT_EQ(2, capture.capture_lost_count());
+}
+
+// Test event capture.
+TEST_F(CocoaMouseCaptureTest, CaptureEvents) {
+  base::scoped_nsobject<CocoaMouseCaptureTestView> view(
+      [[CocoaMouseCaptureTestView alloc] initWithFrame:NSZeroRect]);
+  [test_window() setContentView:view];
+  std::pair<NSEvent*, NSEvent*> click =
+      cocoa_test_event_utils::MouseClickInView(view, 1);
+
+  // First check that the view receives events normally.
+  EXPECT_EQ(0, [view mouseDownCount]);
+  [NSApp sendEvent:click.first];
+  EXPECT_EQ(1, [view mouseDownCount]);
+
+  {
+    TestCaptureDelegate capture;
+    capture.Acquire();
+
+    // Now check that the capture captures events.
+    EXPECT_EQ(0, capture.event_count());
+    [NSApp sendEvent:click.first];
+    EXPECT_EQ(1, [view mouseDownCount]);
+    EXPECT_EQ(1, capture.event_count());
+  }
+
+  // After the capture goes away, events should be received again.
+  [NSApp sendEvent:click.first];
+  EXPECT_EQ(2, [view mouseDownCount]);
+}
+
+}  // namespace views