ui/views/cocoa/bridged_native_widget_interactive_uitest.mm - chromium/src - Git at Google

 // 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 <Cocoa/Cocoa.h>

 #import "base/mac/mac_util.h"
 #import "base/mac/sdk_forward_declarations.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "ui/base/hit_test.h"
 #import "ui/base/test/nswindow_fullscreen_notification_waiter.h"
 #include "ui/base/test/ui_controls.h"
 #import "ui/base/test/windowed_nsnotification_observer.h"
 #import "ui/events/test/cocoa_test_event_utils.h"
 #include "ui/views/test/views_interactive_ui_test_base.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/widget/native_widget_mac.h"
 #include "ui/views/window/native_frame_view.h"

 namespace views {
 namespace test {
 namespace {

 // Provide a resizable Widget by default. Starting in 10.11, OSX doesn't
 // correctly restore the window size when coming out of fullscreen if the window
 // is not user-sizable.
 class ResizableDelegateView : public WidgetDelegateView {
  public:
   ResizableDelegateView() {}

   // WidgetDelgate:
   bool CanResize() const override { return true; }

  private:
   DISALLOW_COPY_AND_ASSIGN(ResizableDelegateView);
 };

 }  // namespace

 class BridgedNativeWidgetUITest : public test::WidgetTest {
  public:
   BridgedNativeWidgetUITest() = default;

   // testing::Test:
   void SetUp() override {
     ViewsInteractiveUITestBase::InteractiveSetUp();
     WidgetTest::SetUp();
     Widget::InitParams init_params =
         CreateParams(Widget::InitParams::TYPE_WINDOW);
     init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     init_params.bounds = gfx::Rect(100, 100, 300, 200);
     init_params.delegate = new ResizableDelegateView;
     widget_.reset(new Widget);
     widget_->Init(init_params);
   }

   void TearDown() override {
     // Ensures any compositor is removed before ViewsTestBase tears down the
     // ContextFactory.
     widget_.reset();
     WidgetTest::TearDown();
   }

   NSWindow* test_window() {
     return widget_->GetNativeWindow();
   }

  protected:
   std::unique_ptr<Widget> widget_;

  private:
   DISALLOW_COPY_AND_ASSIGN(BridgedNativeWidgetUITest);
 };

 // Tests for correct fullscreen tracking, regardless of whether it is initiated
 // by the Widget code or elsewhere (e.g. by the user).
 TEST_F(BridgedNativeWidgetUITest, FullscreenSynchronousState) {
   EXPECT_FALSE(widget_->IsFullscreen());

   // Allow user-initiated fullscreen changes on the Window.
   [test_window()
       setCollectionBehavior:[test_window() collectionBehavior] |
                             NSWindowCollectionBehaviorFullScreenPrimary];

   base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
       [[NSWindowFullscreenNotificationWaiter alloc]
           initWithWindow:test_window()]);
   const gfx::Rect restored_bounds = widget_->GetRestoredBounds();

   // First show the widget. A user shouldn't be able to initiate fullscreen
   // unless the window is visible in the first place.
   widget_->Show();

   // Simulate a user-initiated fullscreen. Note trying to to this again before
   // spinning a runloop will cause Cocoa to emit text to stdio and ignore it.
   [test_window() toggleFullScreen:nil];
   EXPECT_TRUE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   // Note there's now an animation running. While that's happening, toggling the
   // state should work as expected, but do "nothing".
   widget_->SetFullscreen(false);
   EXPECT_FALSE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
   widget_->SetFullscreen(false);  // Same request - should no-op.
   EXPECT_FALSE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   widget_->SetFullscreen(true);
   EXPECT_TRUE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   // Always finish out of fullscreen. Otherwise there are 4 NSWindow objects
   // that Cocoa creates which don't close themselves and will be seen by the Mac
   // test harness on teardown. Note that the test harness will be waiting until
   // all animations complete, since these temporary animation windows will not
   // be removed from the window list until they do.
   widget_->SetFullscreen(false);
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   // Now we must wait for the notifications. Since, if the widget is torn down,
   // the NSWindowDelegate is removed, and the pending request to take out of
   // fullscreen is lost. Since a message loop has not yet spun up in this test
   // we can reliably say there will be one enter and one exit, despite all the
   // toggling above.
   [waiter waitForEnterCount:1 exitCount:1];
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
 }

 // Test fullscreen without overlapping calls and without changing collection
 // behavior on the test window.
 TEST_F(BridgedNativeWidgetUITest, FullscreenEnterAndExit) {
   base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
       [[NSWindowFullscreenNotificationWaiter alloc]
           initWithWindow:test_window()]);

   EXPECT_FALSE(widget_->IsFullscreen());
   const gfx::Rect restored_bounds = widget_->GetRestoredBounds();
   EXPECT_FALSE(restored_bounds.IsEmpty());

   // Ensure this works without having to change collection behavior as for the
   // test above. Also check that making a hidden widget fullscreen shows it.
   EXPECT_FALSE(widget_->IsVisible());
   widget_->SetFullscreen(true);
   EXPECT_TRUE(widget_->IsVisible());

   EXPECT_TRUE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   // Should be zero until the runloop spins.
   EXPECT_EQ(0, [waiter enterCount]);
   [waiter waitForEnterCount:1 exitCount:0];

   // Verify it hasn't exceeded.
   EXPECT_EQ(1, [waiter enterCount]);
   EXPECT_EQ(0, [waiter exitCount]);
   EXPECT_TRUE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   widget_->SetFullscreen(false);
   EXPECT_FALSE(widget_->IsFullscreen());
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

   [waiter waitForEnterCount:1 exitCount:1];
   EXPECT_EQ(1, [waiter enterCount]);
   EXPECT_EQ(1, [waiter exitCount]);
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
 }

 // Test that Widget::Restore exits fullscreen.
 TEST_F(BridgedNativeWidgetUITest, FullscreenRestore) {
   base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
       [[NSWindowFullscreenNotificationWaiter alloc]
           initWithWindow:test_window()]);

   EXPECT_FALSE(widget_->IsFullscreen());
   const gfx::Rect restored_bounds = widget_->GetRestoredBounds();
   EXPECT_FALSE(restored_bounds.IsEmpty());

   widget_->SetFullscreen(true);
   EXPECT_TRUE(widget_->IsFullscreen());
   [waiter waitForEnterCount:1 exitCount:0];

   widget_->Restore();
   EXPECT_FALSE(widget_->IsFullscreen());
   [waiter waitForEnterCount:1 exitCount:1];
   EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
 }

 namespace {

 // This is used to wait for reposted events to be seen. We can't just use
 // RunPendingMessages() because CGEventPost might not be synchronous.
 class HitTestBridgedNativeWidget : public BridgedNativeWidget {
  public:
   explicit HitTestBridgedNativeWidget(NativeWidgetMac* widget)
       : BridgedNativeWidget(widget) {}

   // BridgedNativeWidget:
   bool ShouldRepostPendingLeftMouseDown(NSEvent* event) override {
     did_repost_ = BridgedNativeWidget::ShouldRepostPendingLeftMouseDown(event);

     if (run_loop_)
       run_loop_->Quit();

     return did_repost_;
   }

   void WaitForShouldRepost() {
     base::RunLoop run_loop;
     run_loop_ = &run_loop;
     run_loop.Run();
     run_loop_ = nullptr;
   }

   bool IsDraggable() { return [ns_view() mouseDownCanMoveWindow]; }
   bool did_repost() { return did_repost_; }

  private:
   base::RunLoop* run_loop_ = nullptr;
   bool did_repost_ = false;

   DISALLOW_COPY_AND_ASSIGN(HitTestBridgedNativeWidget);
 };

 // This is used to return a customized result to NonClientHitTest.
 class HitTestNonClientFrameView : public NativeFrameView {
  public:
   explicit HitTestNonClientFrameView(Widget* widget)
       : NativeFrameView(widget), hit_test_result_(HTNOWHERE) {}

   // NonClientFrameView overrides:
   int NonClientHitTest(const gfx::Point& point) override {
     return hit_test_result_;
   }

   void set_hit_test_result(int component) { hit_test_result_ = component; }

  private:
   int hit_test_result_;

   DISALLOW_COPY_AND_ASSIGN(HitTestNonClientFrameView);
 };

 // This is used to change whether the Widget is resizable.
 class HitTestWidgetDelegate : public views::WidgetDelegate {
  public:
   explicit HitTestWidgetDelegate(views::Widget* widget) : widget_(widget) {}

   void set_can_resize(bool can_resize) {
     can_resize_ = can_resize;
     widget_->OnSizeConstraintsChanged();
   }

   // views::WidgetDelegate:
   bool CanResize() const override { return can_resize_; }
   views::Widget* GetWidget() override { return widget_; }
   views::Widget* GetWidget() const override { return widget_; }

  private:
   views::Widget* widget_;
   bool can_resize_ = false;

   DISALLOW_COPY_AND_ASSIGN(HitTestWidgetDelegate);
 };

 void WaitForEvent(NSUInteger mask) {
   // Pointer because the handler block captures local variables by copying.
   base::RunLoop run_loop;
   base::RunLoop* run_loop_ref = &run_loop;
   id monitor = [NSEvent
       addLocalMonitorForEventsMatchingMask:mask
                                    handler:^NSEvent*(NSEvent* ns_event) {
                                      run_loop_ref->Quit();
                                      return ns_event;
                                    }];
   run_loop.Run();
   [NSEvent removeMonitor:monitor];
 }

 }  // namespace

 // This is used to inject test versions of NativeFrameView and
 // BridgedNativeWidget.
 class HitTestNativeWidgetMac : public NativeWidgetMac {
  public:
   HitTestNativeWidgetMac(internal::NativeWidgetDelegate* delegate,
                          NativeFrameView* native_frame_view)
       : NativeWidgetMac(delegate), native_frame_view_(native_frame_view) {
     NativeWidgetMac::bridge_.reset(new HitTestBridgedNativeWidget(this));
   }

   HitTestBridgedNativeWidget* bridge() {
     return static_cast<HitTestBridgedNativeWidget*>(
         NativeWidgetMac::bridge_.get());
   }

   // internal::NativeWidgetPrivate:
   NonClientFrameView* CreateNonClientFrameView() override {
     return native_frame_view_;
   }

  private:
   // Owned by Widget.
   NativeFrameView* native_frame_view_;

   DISALLOW_COPY_AND_ASSIGN(HitTestNativeWidgetMac);
 };

 // Flaky on macOS 10.12. See http://crbug.com/767299.
 TEST_F(BridgedNativeWidgetUITest, DISABLED_HitTest) {
   Widget widget;
   HitTestNonClientFrameView* frame_view =
       new HitTestNonClientFrameView(&widget);
   test::HitTestNativeWidgetMac* native_widget =
       new test::HitTestNativeWidgetMac(&widget, frame_view);
   HitTestWidgetDelegate* widget_delegate = new HitTestWidgetDelegate(&widget);
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.native_widget = native_widget;
   init_params.delegate = widget_delegate;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.bounds = gfx::Rect(100, 200, 400, 300);
   widget.Init(init_params);

   WidgetActivationWaiter activation_waiter(&widget, true);
   widget.Show();
   activation_waiter.Wait();

   // Points inside the resize area.
   const NSPoint bottom_right_point = {398, 2};
   const NSPoint right_of_bottom_right = {398 + 10, 2};

   NSWindow* window = widget.GetNativeWindow();

   EXPECT_FALSE([window ignoresMouseEvents]);
   // OSX uses both the alpha value of the window and the underlying CALayer to
   // decide whether to send mouse events to window, in case [window
   // ignoresMouseEvent] is not explicitly initialized. Since, no frames are
   // drawn during tests and the underlying CALayer has a transparent background,
   // explicitly call setIgnoresMouseEvents: to ensure the window receives the
   // mouse events.
   [window setIgnoresMouseEvents:NO];

   HitTestBridgedNativeWidget* bridge = native_widget->bridge();

   const bool using_drag_event_monitor =
       BridgedNativeWidget::ShouldUseDragEventMonitor();

   // Dragging the window should work.
   frame_view->set_hit_test_result(HTCAPTION);
   {
     EXPECT_EQ(100, [window frame].origin.x);

     base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowWillMoveNotification]);
     NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
         NSMakePoint(20, 20), window);
     EXPECT_FALSE(bridge->IsDraggable());
     CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
     if (using_drag_event_monitor) {
       bridge->WaitForShouldRepost();
       EXPECT_TRUE(bridge->did_repost());
       EXPECT_TRUE(bridge->IsDraggable());
       bridge->WaitForShouldRepost();
       EXPECT_FALSE(bridge->did_repost());
       EXPECT_FALSE(bridge->IsDraggable());
     } else {
       WaitForEvent(NSLeftMouseDownMask);
     }

     base::scoped_nsobject<WindowedNSNotificationObserver> did_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowDidMoveNotification]);
     NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
         NSMakePoint(30, 30), NSLeftMouseDragged, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
     WaitForEvent(NSLeftMouseDraggedMask);
     // NSWindowWillMoveNotification should have been observed by the time the
     // mouse drag event is received.
     EXPECT_EQ(1, [will_move_observer notificationCount]);
     EXPECT_TRUE([did_move_observer wait]);
     EXPECT_EQ(110, [window frame].origin.x);

     NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
         NSMakePoint(20, 20), NSLeftMouseUp, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
     WaitForEvent(NSLeftMouseUpMask);
     EXPECT_EQ(110, [window frame].origin.x);
   }

   // Dragging in the resize area works since the widget is not resizable.
   {
     EXPECT_EQ(110, [window frame].origin.x);

     base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowWillMoveNotification]);
     NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
         bottom_right_point, window);
     EXPECT_FALSE(bridge->IsDraggable());
     CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
     if (using_drag_event_monitor) {
       bridge->WaitForShouldRepost();
       EXPECT_TRUE(bridge->did_repost());
       EXPECT_TRUE(bridge->IsDraggable());
       bridge->WaitForShouldRepost();
       EXPECT_FALSE(bridge->did_repost());
       EXPECT_FALSE(bridge->IsDraggable());
     } else {
       WaitForEvent(NSLeftMouseDownMask);
     }

     base::scoped_nsobject<WindowedNSNotificationObserver> did_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowDidMoveNotification]);
     NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
         right_of_bottom_right, NSLeftMouseDragged, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
     WaitForEvent(NSLeftMouseDraggedMask);
     EXPECT_EQ(1, [will_move_observer notificationCount]);
     EXPECT_TRUE([did_move_observer wait]);
     EXPECT_EQ(120, [window frame].origin.x);

     NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
         bottom_right_point, NSLeftMouseUp, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
     WaitForEvent(NSLeftMouseUpMask);
     EXPECT_EQ(120, [window frame].origin.x);
   }

   // If the widget is resizable, dragging in the resize area should not repost
   // (and should resize).
   widget_delegate->set_can_resize(true);
   {
     EXPECT_EQ(400, [window frame].size.width);

     NSUInteger x = [window frame].origin.x;
     NSUInteger y = [window frame].origin.y;

     // Enqueue all mouse events first because AppKit will run its own loop to
     // consume them.
     base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowWillMoveNotification]);
     NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
         bottom_right_point, window);
     EXPECT_FALSE(bridge->IsDraggable());
     CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);

     base::scoped_nsobject<WindowedNSNotificationObserver> did_resize_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowDidResizeNotification]);
     NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPoint(
         NSMakePoint(x + 408, y + 2), NSLeftMouseDragged, 0);
     CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);

     NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPoint(
         NSMakePoint(x + 408, y + 2), NSLeftMouseUp, 0);
     CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);

     if (using_drag_event_monitor) {
       // The only event observed by us is the original mouse-down. It should not
       // be reposted.
       bridge->WaitForShouldRepost();
       EXPECT_FALSE(bridge->did_repost());
       EXPECT_FALSE(bridge->IsDraggable());
     }

     EXPECT_TRUE([did_resize_observer wait]);
     EXPECT_EQ(0, [will_move_observer notificationCount]);
     EXPECT_EQ(410, [window frame].size.width);

     // Origin is unchanged.
     EXPECT_EQ(x, [window frame].origin.x);
     EXPECT_EQ(y, [window frame].origin.y);
   }

   // Mouse-downs on the window controls should not be intercepted.
   {
     EXPECT_EQ(120, [window frame].origin.x);

     base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowWillMoveNotification]);
     base::scoped_nsobject<WindowedNSNotificationObserver>
         did_miniaturize_observer([[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowDidMiniaturizeNotification]);

     // Position this on the minimize button.
     NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
         NSMakePoint(30, 290), window);
     CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);

     NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
         NSMakePoint(30, 290), NSLeftMouseUp, window, 0);
     EXPECT_FALSE([window isMiniaturized]);
     CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
     [did_miniaturize_observer wait];
     EXPECT_EQ(0, [will_move_observer notificationCount]);
     EXPECT_TRUE([window isMiniaturized]);
     [window deminiaturize:nil];

     // Position unchanged.
     EXPECT_EQ(120, [window frame].origin.x);
   }

   // Non-draggable areas should do nothing.
   frame_view->set_hit_test_result(HTCLIENT);
   {
     EXPECT_EQ(120, [window frame].origin.x);

     base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
         [[WindowedNSNotificationObserver alloc]
             initForNotification:NSWindowWillMoveNotification]);
     NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
         NSMakePoint(20, 20), window);
     CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
     WaitForEvent(NSLeftMouseDownMask);

     NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
         NSMakePoint(30, 30), NSLeftMouseDragged, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
     WaitForEvent(NSLeftMouseDraggedMask);
     EXPECT_EQ(0, [will_move_observer notificationCount]);
     EXPECT_EQ(120, [window frame].origin.x);

     NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
         NSMakePoint(30, 30), NSLeftMouseUp, window, 0);
     CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
     WaitForEvent(NSLeftMouseUpMask);
     EXPECT_EQ(120, [window frame].origin.x);
   }
 }

 }  // namespace test
 }  // namespace views
	// 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 <Cocoa/Cocoa.h>

	#import "base/mac/mac_util.h"
	#import "base/mac/sdk_forward_declarations.h"
	#include "base/macros.h"
	#include "base/run_loop.h"
	#include "ui/base/hit_test.h"
	#import "ui/base/test/nswindow_fullscreen_notification_waiter.h"
	#include "ui/base/test/ui_controls.h"
	#import "ui/base/test/windowed_nsnotification_observer.h"
	#import "ui/events/test/cocoa_test_event_utils.h"
	#include "ui/views/test/views_interactive_ui_test_base.h"
	#include "ui/views/test/widget_test.h"
	#include "ui/views/widget/native_widget_mac.h"
	#include "ui/views/window/native_frame_view.h"

	namespace views {
	namespace test {
	namespace {

	// Provide a resizable Widget by default. Starting in 10.11, OSX doesn't
	// correctly restore the window size when coming out of fullscreen if the window
	// is not user-sizable.
	class ResizableDelegateView : public WidgetDelegateView {
	public:
	ResizableDelegateView() {}

	// WidgetDelgate:
	bool CanResize() const override { return true; }

	private:
	DISALLOW_COPY_AND_ASSIGN(ResizableDelegateView);
	};

	} // namespace

	class BridgedNativeWidgetUITest : public test::WidgetTest {
	public:
	BridgedNativeWidgetUITest() = default;

	// testing::Test:
	void SetUp() override {
	ViewsInteractiveUITestBase::InteractiveSetUp();
	WidgetTest::SetUp();
	Widget::InitParams init_params =
	CreateParams(Widget::InitParams::TYPE_WINDOW);
	init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
	init_params.bounds = gfx::Rect(100, 100, 300, 200);
	init_params.delegate = new ResizableDelegateView;
	widget_.reset(new Widget);
	widget_->Init(init_params);
	}

	void TearDown() override {
	// Ensures any compositor is removed before ViewsTestBase tears down the
	// ContextFactory.
	widget_.reset();
	WidgetTest::TearDown();
	}

	NSWindow* test_window() {
	return widget_->GetNativeWindow();
	}

	protected:
	std::unique_ptr<Widget> widget_;

	private:
	DISALLOW_COPY_AND_ASSIGN(BridgedNativeWidgetUITest);
	};

	// Tests for correct fullscreen tracking, regardless of whether it is initiated
	// by the Widget code or elsewhere (e.g. by the user).
	TEST_F(BridgedNativeWidgetUITest, FullscreenSynchronousState) {
	EXPECT_FALSE(widget_->IsFullscreen());

	// Allow user-initiated fullscreen changes on the Window.
	[test_window()
	setCollectionBehavior:[test_window() collectionBehavior] \|
	NSWindowCollectionBehaviorFullScreenPrimary];

	base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
	[[NSWindowFullscreenNotificationWaiter alloc]
	initWithWindow:test_window()]);
	const gfx::Rect restored_bounds = widget_->GetRestoredBounds();

	// First show the widget. A user shouldn't be able to initiate fullscreen
	// unless the window is visible in the first place.
	widget_->Show();

	// Simulate a user-initiated fullscreen. Note trying to to this again before
	// spinning a runloop will cause Cocoa to emit text to stdio and ignore it.
	[test_window() toggleFullScreen:nil];
	EXPECT_TRUE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	// Note there's now an animation running. While that's happening, toggling the
	// state should work as expected, but do "nothing".
	widget_->SetFullscreen(false);
	EXPECT_FALSE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
	widget_->SetFullscreen(false); // Same request - should no-op.
	EXPECT_FALSE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	widget_->SetFullscreen(true);
	EXPECT_TRUE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	// Always finish out of fullscreen. Otherwise there are 4 NSWindow objects
	// that Cocoa creates which don't close themselves and will be seen by the Mac
	// test harness on teardown. Note that the test harness will be waiting until
	// all animations complete, since these temporary animation windows will not
	// be removed from the window list until they do.
	widget_->SetFullscreen(false);
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	// Now we must wait for the notifications. Since, if the widget is torn down,
	// the NSWindowDelegate is removed, and the pending request to take out of
	// fullscreen is lost. Since a message loop has not yet spun up in this test
	// we can reliably say there will be one enter and one exit, despite all the
	// toggling above.
	[waiter waitForEnterCount:1 exitCount:1];
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
	}

	// Test fullscreen without overlapping calls and without changing collection
	// behavior on the test window.
	TEST_F(BridgedNativeWidgetUITest, FullscreenEnterAndExit) {
	base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
	[[NSWindowFullscreenNotificationWaiter alloc]
	initWithWindow:test_window()]);

	EXPECT_FALSE(widget_->IsFullscreen());
	const gfx::Rect restored_bounds = widget_->GetRestoredBounds();
	EXPECT_FALSE(restored_bounds.IsEmpty());

	// Ensure this works without having to change collection behavior as for the
	// test above. Also check that making a hidden widget fullscreen shows it.
	EXPECT_FALSE(widget_->IsVisible());
	widget_->SetFullscreen(true);
	EXPECT_TRUE(widget_->IsVisible());

	EXPECT_TRUE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	// Should be zero until the runloop spins.
	EXPECT_EQ(0, [waiter enterCount]);
	[waiter waitForEnterCount:1 exitCount:0];

	// Verify it hasn't exceeded.
	EXPECT_EQ(1, [waiter enterCount]);
	EXPECT_EQ(0, [waiter exitCount]);
	EXPECT_TRUE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	widget_->SetFullscreen(false);
	EXPECT_FALSE(widget_->IsFullscreen());
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());

	[waiter waitForEnterCount:1 exitCount:1];
	EXPECT_EQ(1, [waiter enterCount]);
	EXPECT_EQ(1, [waiter exitCount]);
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
	}

	// Test that Widget::Restore exits fullscreen.
	TEST_F(BridgedNativeWidgetUITest, FullscreenRestore) {
	base::scoped_nsobject<NSWindowFullscreenNotificationWaiter> waiter(
	[[NSWindowFullscreenNotificationWaiter alloc]
	initWithWindow:test_window()]);

	EXPECT_FALSE(widget_->IsFullscreen());
	const gfx::Rect restored_bounds = widget_->GetRestoredBounds();
	EXPECT_FALSE(restored_bounds.IsEmpty());

	widget_->SetFullscreen(true);
	EXPECT_TRUE(widget_->IsFullscreen());
	[waiter waitForEnterCount:1 exitCount:0];

	widget_->Restore();
	EXPECT_FALSE(widget_->IsFullscreen());
	[waiter waitForEnterCount:1 exitCount:1];
	EXPECT_EQ(restored_bounds, widget_->GetRestoredBounds());
	}

	namespace {

	// This is used to wait for reposted events to be seen. We can't just use
	// RunPendingMessages() because CGEventPost might not be synchronous.
	class HitTestBridgedNativeWidget : public BridgedNativeWidget {
	public:
	explicit HitTestBridgedNativeWidget(NativeWidgetMac* widget)
	: BridgedNativeWidget(widget) {}

	// BridgedNativeWidget:
	bool ShouldRepostPendingLeftMouseDown(NSEvent* event) override {
	did_repost_ = BridgedNativeWidget::ShouldRepostPendingLeftMouseDown(event);

	if (run_loop_)
	run_loop_->Quit();

	return did_repost_;
	}

	void WaitForShouldRepost() {
	base::RunLoop run_loop;
	run_loop_ = &run_loop;
	run_loop.Run();
	run_loop_ = nullptr;
	}

	bool IsDraggable() { return [ns_view() mouseDownCanMoveWindow]; }
	bool did_repost() { return did_repost_; }

	private:
	base::RunLoop* run_loop_ = nullptr;
	bool did_repost_ = false;

	DISALLOW_COPY_AND_ASSIGN(HitTestBridgedNativeWidget);
	};

	// This is used to return a customized result to NonClientHitTest.
	class HitTestNonClientFrameView : public NativeFrameView {
	public:
	explicit HitTestNonClientFrameView(Widget* widget)
	: NativeFrameView(widget), hit_test_result_(HTNOWHERE) {}

	// NonClientFrameView overrides:
	int NonClientHitTest(const gfx::Point& point) override {
	return hit_test_result_;
	}

	void set_hit_test_result(int component) { hit_test_result_ = component; }

	private:
	int hit_test_result_;

	DISALLOW_COPY_AND_ASSIGN(HitTestNonClientFrameView);
	};

	// This is used to change whether the Widget is resizable.
	class HitTestWidgetDelegate : public views::WidgetDelegate {
	public:
	explicit HitTestWidgetDelegate(views::Widget* widget) : widget_(widget) {}

	void set_can_resize(bool can_resize) {
	can_resize_ = can_resize;
	widget_->OnSizeConstraintsChanged();
	}

	// views::WidgetDelegate:
	bool CanResize() const override { return can_resize_; }
	views::Widget* GetWidget() override { return widget_; }
	views::Widget* GetWidget() const override { return widget_; }

	private:
	views::Widget* widget_;
	bool can_resize_ = false;

	DISALLOW_COPY_AND_ASSIGN(HitTestWidgetDelegate);
	};

	void WaitForEvent(NSUInteger mask) {
	// Pointer because the handler block captures local variables by copying.
	base::RunLoop run_loop;
	base::RunLoop* run_loop_ref = &run_loop;
	id monitor = [NSEvent
	addLocalMonitorForEventsMatchingMask:mask
	handler:^NSEvent(NSEvent ns_event) {
	run_loop_ref->Quit();
	return ns_event;
	}];
	run_loop.Run();
	[NSEvent removeMonitor:monitor];
	}

	} // namespace

	// This is used to inject test versions of NativeFrameView and
	// BridgedNativeWidget.
	class HitTestNativeWidgetMac : public NativeWidgetMac {
	public:
	HitTestNativeWidgetMac(internal::NativeWidgetDelegate* delegate,
	NativeFrameView* native_frame_view)
	: NativeWidgetMac(delegate), native_frame_view_(native_frame_view) {
	NativeWidgetMac::bridge_.reset(new HitTestBridgedNativeWidget(this));
	}

	HitTestBridgedNativeWidget* bridge() {
	return static_cast<HitTestBridgedNativeWidget*>(
	NativeWidgetMac::bridge_.get());
	}

	// internal::NativeWidgetPrivate:
	NonClientFrameView* CreateNonClientFrameView() override {
	return native_frame_view_;
	}

	private:
	// Owned by Widget.
	NativeFrameView* native_frame_view_;

	DISALLOW_COPY_AND_ASSIGN(HitTestNativeWidgetMac);
	};

	// Flaky on macOS 10.12. See http://crbug.com/767299.
	TEST_F(BridgedNativeWidgetUITest, DISABLED_HitTest) {
	Widget widget;
	HitTestNonClientFrameView* frame_view =
	new HitTestNonClientFrameView(&widget);
	test::HitTestNativeWidgetMac* native_widget =
	new test::HitTestNativeWidgetMac(&widget, frame_view);
	HitTestWidgetDelegate* widget_delegate = new HitTestWidgetDelegate(&widget);
	Widget::InitParams init_params =
	CreateParams(Widget::InitParams::TYPE_WINDOW);
	init_params.native_widget = native_widget;
	init_params.delegate = widget_delegate;
	init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
	init_params.bounds = gfx::Rect(100, 200, 400, 300);
	widget.Init(init_params);

	WidgetActivationWaiter activation_waiter(&widget, true);
	widget.Show();
	activation_waiter.Wait();

	// Points inside the resize area.
	const NSPoint bottom_right_point = {398, 2};
	const NSPoint right_of_bottom_right = {398 + 10, 2};

	NSWindow* window = widget.GetNativeWindow();

	EXPECT_FALSE([window ignoresMouseEvents]);
	// OSX uses both the alpha value of the window and the underlying CALayer to
	// decide whether to send mouse events to window, in case [window
	// ignoresMouseEvent] is not explicitly initialized. Since, no frames are
	// drawn during tests and the underlying CALayer has a transparent background,
	// explicitly call setIgnoresMouseEvents: to ensure the window receives the
	// mouse events.
	[window setIgnoresMouseEvents:NO];

	HitTestBridgedNativeWidget* bridge = native_widget->bridge();

	const bool using_drag_event_monitor =
	BridgedNativeWidget::ShouldUseDragEventMonitor();

	// Dragging the window should work.
	frame_view->set_hit_test_result(HTCAPTION);
	{
	EXPECT_EQ(100, [window frame].origin.x);

	base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowWillMoveNotification]);
	NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
	NSMakePoint(20, 20), window);
	EXPECT_FALSE(bridge->IsDraggable());
	CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
	if (using_drag_event_monitor) {
	bridge->WaitForShouldRepost();
	EXPECT_TRUE(bridge->did_repost());
	EXPECT_TRUE(bridge->IsDraggable());
	bridge->WaitForShouldRepost();
	EXPECT_FALSE(bridge->did_repost());
	EXPECT_FALSE(bridge->IsDraggable());
	} else {
	WaitForEvent(NSLeftMouseDownMask);
	}

	base::scoped_nsobject<WindowedNSNotificationObserver> did_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowDidMoveNotification]);
	NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
	NSMakePoint(30, 30), NSLeftMouseDragged, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
	WaitForEvent(NSLeftMouseDraggedMask);
	// NSWindowWillMoveNotification should have been observed by the time the
	// mouse drag event is received.
	EXPECT_EQ(1, [will_move_observer notificationCount]);
	EXPECT_TRUE([did_move_observer wait]);
	EXPECT_EQ(110, [window frame].origin.x);

	NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
	NSMakePoint(20, 20), NSLeftMouseUp, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
	WaitForEvent(NSLeftMouseUpMask);
	EXPECT_EQ(110, [window frame].origin.x);
	}

	// Dragging in the resize area works since the widget is not resizable.
	{
	EXPECT_EQ(110, [window frame].origin.x);

	base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowWillMoveNotification]);
	NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
	bottom_right_point, window);
	EXPECT_FALSE(bridge->IsDraggable());
	CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
	if (using_drag_event_monitor) {
	bridge->WaitForShouldRepost();
	EXPECT_TRUE(bridge->did_repost());
	EXPECT_TRUE(bridge->IsDraggable());
	bridge->WaitForShouldRepost();
	EXPECT_FALSE(bridge->did_repost());
	EXPECT_FALSE(bridge->IsDraggable());
	} else {
	WaitForEvent(NSLeftMouseDownMask);
	}

	base::scoped_nsobject<WindowedNSNotificationObserver> did_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowDidMoveNotification]);
	NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
	right_of_bottom_right, NSLeftMouseDragged, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
	WaitForEvent(NSLeftMouseDraggedMask);
	EXPECT_EQ(1, [will_move_observer notificationCount]);
	EXPECT_TRUE([did_move_observer wait]);
	EXPECT_EQ(120, [window frame].origin.x);

	NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
	bottom_right_point, NSLeftMouseUp, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
	WaitForEvent(NSLeftMouseUpMask);
	EXPECT_EQ(120, [window frame].origin.x);
	}

	// If the widget is resizable, dragging in the resize area should not repost
	// (and should resize).
	widget_delegate->set_can_resize(true);
	{
	EXPECT_EQ(400, [window frame].size.width);

	NSUInteger x = [window frame].origin.x;
	NSUInteger y = [window frame].origin.y;

	// Enqueue all mouse events first because AppKit will run its own loop to
	// consume them.
	base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowWillMoveNotification]);
	NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
	bottom_right_point, window);
	EXPECT_FALSE(bridge->IsDraggable());
	CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);

	base::scoped_nsobject<WindowedNSNotificationObserver> did_resize_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowDidResizeNotification]);
	NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPoint(
	NSMakePoint(x + 408, y + 2), NSLeftMouseDragged, 0);
	CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);

	NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPoint(
	NSMakePoint(x + 408, y + 2), NSLeftMouseUp, 0);
	CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);

	if (using_drag_event_monitor) {
	// The only event observed by us is the original mouse-down. It should not
	// be reposted.
	bridge->WaitForShouldRepost();
	EXPECT_FALSE(bridge->did_repost());
	EXPECT_FALSE(bridge->IsDraggable());
	}

	EXPECT_TRUE([did_resize_observer wait]);
	EXPECT_EQ(0, [will_move_observer notificationCount]);
	EXPECT_EQ(410, [window frame].size.width);

	// Origin is unchanged.
	EXPECT_EQ(x, [window frame].origin.x);
	EXPECT_EQ(y, [window frame].origin.y);
	}

	// Mouse-downs on the window controls should not be intercepted.
	{
	EXPECT_EQ(120, [window frame].origin.x);

	base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowWillMoveNotification]);
	base::scoped_nsobject<WindowedNSNotificationObserver>
	did_miniaturize_observer([[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowDidMiniaturizeNotification]);

	// Position this on the minimize button.
	NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
	NSMakePoint(30, 290), window);
	CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);

	NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
	NSMakePoint(30, 290), NSLeftMouseUp, window, 0);
	EXPECT_FALSE([window isMiniaturized]);
	CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
	[did_miniaturize_observer wait];
	EXPECT_EQ(0, [will_move_observer notificationCount]);
	EXPECT_TRUE([window isMiniaturized]);
	[window deminiaturize:nil];

	// Position unchanged.
	EXPECT_EQ(120, [window frame].origin.x);
	}

	// Non-draggable areas should do nothing.
	frame_view->set_hit_test_result(HTCLIENT);
	{
	EXPECT_EQ(120, [window frame].origin.x);

	base::scoped_nsobject<WindowedNSNotificationObserver> will_move_observer(
	[[WindowedNSNotificationObserver alloc]
	initForNotification:NSWindowWillMoveNotification]);
	NSEvent* mouse_down = cocoa_test_event_utils::LeftMouseDownAtPointInWindow(
	NSMakePoint(20, 20), window);
	CGEventPost(kCGSessionEventTap, [mouse_down CGEvent]);
	WaitForEvent(NSLeftMouseDownMask);

	NSEvent* mouse_drag = cocoa_test_event_utils::MouseEventAtPointInWindow(
	NSMakePoint(30, 30), NSLeftMouseDragged, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_drag CGEvent]);
	WaitForEvent(NSLeftMouseDraggedMask);
	EXPECT_EQ(0, [will_move_observer notificationCount]);
	EXPECT_EQ(120, [window frame].origin.x);

	NSEvent* mouse_up = cocoa_test_event_utils::MouseEventAtPointInWindow(
	NSMakePoint(30, 30), NSLeftMouseUp, window, 0);
	CGEventPost(kCGSessionEventTap, [mouse_up CGEvent]);
	WaitForEvent(NSLeftMouseUpMask);
	EXPECT_EQ(120, [window frame].origin.x);
	}
	}

	} // namespace test
	} // namespace views