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

chrome/browser/apps/app_shim/app_shim_interactive_uitest_mac.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 <Cocoa/Cocoa.h>
 #include <vector>
 
 #include "apps/app_lifetime_monitor_factory.h"
 #include "apps/switches.h"
 #include "base/auto_reset.h"
@@ skipping 17 matching lines @@
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/web_applications/web_app_mac.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/mac/app_mode_common.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/test/extension_test_message_listener.h"
+#import "ui/base/test/windowed_nsnotification_observer.h"
 #import "ui/events/test/cocoa_test_event_utils.h"
 
 namespace {
 
 // General end-to-end test for app shims.
 class AppShimInteractiveTest : public extensions::PlatformAppBrowserTest {
  protected:
   AppShimInteractiveTest()
       : auto_reset_(&g_app_shims_allow_update_and_launch_in_tests, true) {}
 
@@ skipping 246 matching lines @@
     const extensions::Extension* extension =
         apps::ExtensionAppShimHandler::MaybeGetAppForBrowser(browser);
     if (extension && extension->is_hosted_app())
       return browser;
   }
   return nullptr;
 }
 
 }  // namespace
 
-// Watches for NSNotifications from the shared workspace.
-@interface WindowedNSNotificationObserver : NSObject {
- @private
-  base::scoped_nsobject<NSString> bundleId_;
-  BOOL notificationReceived_;
-  scoped_ptr<base::RunLoop> runLoop_;
-}
-
-- (id)initForNotification:(NSString*)name
-              andBundleId:(NSString*)bundleId;
-- (void)observe:(NSNotification*)notification;
-- (void)wait;
-@end
-
-@implementation WindowedNSNotificationObserver
-
-- (id)initForNotification:(NSString*)name
-              andBundleId:(NSString*)bundleId {
-  if (self = [super init]) {
-    bundleId_.reset([[bundleId copy] retain]);
-    [[[NSWorkspace sharedWorkspace] notificationCenter]
-        addObserver:self
-           selector:@selector(observe:)
-               name:name
-             object:nil];
-  }
-  return self;
-}
-
-- (void)observe:(NSNotification*)notification {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
-  NSRunningApplication* application =
-      [[notification userInfo] objectForKey:NSWorkspaceApplicationKey];
-  if (![[application bundleIdentifier] isEqualToString:bundleId_])
-    return;
-
-  [[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:self];
-  notificationReceived_ = YES;
-  if (runLoop_.get())
-    runLoop_->Quit();
-}
-
-- (void)wait {
-  if (notificationReceived_)
-    return;
-
-  runLoop_.reset(new base::RunLoop);
-  runLoop_->Run();
-}
-
-@end
-
 namespace apps {
 
 // Shims require static libraries http://crbug.com/386024.
 #if defined(COMPONENT_BUILD)
 #define MAYBE_Launch DISABLED_Launch
 #define MAYBE_HostedAppLaunch DISABLED_HostedAppLaunch
 #define MAYBE_ShowWindow DISABLED_ShowWindow
 #define MAYBE_RebuildShim DISABLED_RebuildShim
 #else
 #define MAYBE_Launch Launch
@@ skipping 13 matching lines @@
   NSString* bundle_id = GetBundleID(shim_path);
 
   // Explicitly set the launch type to open in a new window.
   extensions::SetLaunchType(profile(), app->id(),
                             extensions::LAUNCH_TYPE_WINDOW);
 
   // Case 1: Launch the hosted app, it should start the shim.
   {
     base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer;
     ns_observer.reset([[WindowedNSNotificationObserver alloc]
-        initForNotification:NSWorkspaceDidLaunchApplicationNotification
-                andBundleId:bundle_id]);
+        initForWorkspaceNotification:NSWorkspaceDidLaunchApplicationNotification
+                            bundleId:bundle_id]);
     WindowedAppShimLaunchObserver observer(app->id());
     LaunchHostedApp(app);
     [ns_observer wait];
     observer.Wait();
 
     EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
     EXPECT_TRUE(GetFirstHostedAppWindow());
 
     NSArray* running_shim = [NSRunningApplication
         runningApplicationsWithBundleIdentifier:bundle_id];
     ASSERT_EQ(1u, [running_shim count]);
 
     ns_observer.reset([[WindowedNSNotificationObserver alloc]
-        initForNotification:NSWorkspaceDidTerminateApplicationNotification
-                andBundleId:bundle_id]);
+        initForWorkspaceNotification:
+            NSWorkspaceDidTerminateApplicationNotification
+                            bundleId:bundle_id]);
     [base::mac::ObjCCastStrict<NSRunningApplication>(
         [running_shim objectAtIndex:0]) terminate];
     [ns_observer wait];
 
     EXPECT_FALSE(GetFirstHostedAppWindow());
     EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   }
 
   // Case 2: Launch the shim, it should start the hosted app.
   {
@@ skipping 34 matching lines @@
   EXPECT_FALSE(base::PathExists(shim_path));
 
   UpdateAppAndAwaitShimCreation(profile(), app, shim_path);
   ASSERT_TRUE(base::PathExists(shim_path));
   NSString* bundle_id = GetBundleID(shim_path);
 
   // Case 1: Launch the app, it should start the shim.
   {
     base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer;
     ns_observer.reset([[WindowedNSNotificationObserver alloc]
-        initForNotification:NSWorkspaceDidLaunchApplicationNotification
-                andBundleId:bundle_id]);
+        initForWorkspaceNotification:NSWorkspaceDidLaunchApplicationNotification
+                            bundleId:bundle_id]);
     WindowedAppShimLaunchObserver observer(app->id());
     LaunchPlatformApp(app);
     [ns_observer wait];
     observer.Wait();
 
     EXPECT_TRUE(GetFirstAppWindow());
     EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
 
     // Quitting the shim will eventually cause it to quit. It actually
     // intercepts the -terminate, sends an AppShimHostMsg_QuitApp to Chrome,
     // and returns NSTerminateLater. Chrome responds by closing all windows of
     // the app. Once all windows are closed, Chrome closes the IPC channel,
     // which causes the shim to actually terminate.
     NSArray* running_shim = [NSRunningApplication
         runningApplicationsWithBundleIdentifier:bundle_id];
     ASSERT_EQ(1u, [running_shim count]);
 
     ns_observer.reset([[WindowedNSNotificationObserver alloc]
-        initForNotification:NSWorkspaceDidTerminateApplicationNotification
-                andBundleId:bundle_id]);
+        initForWorkspaceNotification:
+            NSWorkspaceDidTerminateApplicationNotification
+                            bundleId:bundle_id]);
     [base::mac::ObjCCastStrict<NSRunningApplication>(
         [running_shim objectAtIndex:0]) terminate];
     [ns_observer wait];
 
     EXPECT_FALSE(GetFirstAppWindow());
     EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   }
 
   // Case 2: Launch the shim, it should start the app.
   {
@@ skipping 46 matching lines @@
     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
   }
   extensions::AppWindow* window_1 = GetFirstAppWindow();
   ASSERT_TRUE(window_1);
   EXPECT_TRUE(window_1->is_hidden());
   EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   EXPECT_EQ(0, lifetime_observer.activated_count());
 
   // Showing the window causes the shim to launch.
   {
-    base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer(
-        [[WindowedNSNotificationObserver alloc]
-            initForNotification:NSWorkspaceDidLaunchApplicationNotification
-                    andBundleId:bundle_id]);
+    base::scoped_nsobject<WindowedNSNotificationObserver>
+    ns_observer([[WindowedNSNotificationObserver alloc]
+        initForWorkspaceNotification:NSWorkspaceDidLaunchApplicationNotification
+                            bundleId:bundle_id]);
     WindowedAppShimLaunchObserver observer(app->id());
     window_1->Show(extensions::AppWindow::SHOW_INACTIVE);
     [ns_observer wait];
     observer.Wait();
     EXPECT_EQ(1, lifetime_observer.activated_count());
     EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
   }
 
   // Hiding the window causes the shim to quit.
   {
     base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer(
         [[WindowedNSNotificationObserver alloc]
-            initForNotification:NSWorkspaceDidTerminateApplicationNotification
-                    andBundleId:bundle_id]);
+            initForWorkspaceNotification:
+                NSWorkspaceDidTerminateApplicationNotification
+                                bundleId:bundle_id]);
     window_1->Hide();
     [ns_observer wait];
     EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   }
 
   // Launch a second window. It should not launch the shim.
   {
     ExtensionTestMessageListener launched_listener("Launched", false);
     LaunchPlatformApp(app);
     EXPECT_TRUE(launched_listener.WaitUntilSatisfied());
   }
   const extensions::AppWindowRegistry::AppWindowList& app_windows =
       extensions::AppWindowRegistry::Get(profile())->app_windows();
   EXPECT_EQ(2u, app_windows.size());
   extensions::AppWindow* window_2 = app_windows.front();
   EXPECT_NE(window_1, window_2);
   ASSERT_TRUE(window_2);
   EXPECT_TRUE(window_2->is_hidden());
   EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   EXPECT_EQ(1, lifetime_observer.activated_count());
 
   // Showing one of the windows should launch the shim.
   {
-    base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer(
-        [[WindowedNSNotificationObserver alloc]
-            initForNotification:NSWorkspaceDidLaunchApplicationNotification
-                    andBundleId:bundle_id]);
+    base::scoped_nsobject<WindowedNSNotificationObserver>
+    ns_observer([[WindowedNSNotificationObserver alloc]
+        initForWorkspaceNotification:NSWorkspaceDidLaunchApplicationNotification
+                            bundleId:bundle_id]);
     WindowedAppShimLaunchObserver observer(app->id());
     window_1->Show(extensions::AppWindow::SHOW_INACTIVE);
     [ns_observer wait];
     observer.Wait();
     EXPECT_EQ(2, lifetime_observer.activated_count());
     EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
     EXPECT_TRUE(window_2->is_hidden());
   }
 
   // Showing the other window does nothing.
@@ skipping 14 matching lines @@
     window_1->Hide();
     EXPECT_EQ(0, deactivate_observer.deactivated_count());
   }
 
   // Hiding other window causes the shim to quit.
   {
     AppLifetimeMonitorObserver deactivate_observer(profile());
     EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
     base::scoped_nsobject<WindowedNSNotificationObserver> ns_observer(
         [[WindowedNSNotificationObserver alloc]
-            initForNotification:NSWorkspaceDidTerminateApplicationNotification
-                    andBundleId:bundle_id]);
+            initForWorkspaceNotification:
+                NSWorkspaceDidTerminateApplicationNotification
+                                bundleId:bundle_id]);
     window_2->Hide();
     [ns_observer wait];
     EXPECT_EQ(1, deactivate_observer.deactivated_count());
     EXPECT_FALSE(HasAppShimHost(profile(), app->id()));
   }
 }
 
 #if defined(ARCH_CPU_64_BITS)
 
 // Tests that a 32 bit shim attempting to launch 64 bit Chrome will eventually
@@ skipping 77 matching lines @@
   // the shim is rebuilt.
   WindowedAppShimLaunchObserver(app->id()).Wait();
 
   EXPECT_TRUE(GetFirstAppWindow());
   EXPECT_TRUE(HasAppShimHost(profile(), app->id()));
 }
 
 #endif  // defined(ARCH_CPU_64_BITS)
 
 }  // namespace apps