Home | History | Annotate | Download | only in browser 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #import <Carbon/Carbon.h>
      6 #import <Cocoa/Cocoa.h>
      7 #import <Foundation/Foundation.h>
      8 #import <Foundation/NSAppleEventDescriptor.h>
      9 #import <objc/message.h>
     10 #import <objc/runtime.h>
     11 
     12 #include "base/command_line.h"
     13 #include "base/mac/foundation_util.h"
     14 #include "base/mac/scoped_nsobject.h"
     15 #include "base/prefs/pref_service.h"
     16 #include "chrome/app/chrome_command_ids.h"
     17 #import "chrome/browser/app_controller_mac.h"
     18 #include "chrome/browser/apps/app_browsertest_util.h"
     19 #include "chrome/browser/browser_process.h"
     20 #include "chrome/browser/profiles/profile_manager.h"
     21 #include "chrome/browser/ui/browser.h"
     22 #include "chrome/browser/ui/browser_list.h"
     23 #include "chrome/browser/ui/browser_window.h"
     24 #include "chrome/browser/ui/host_desktop.h"
     25 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     26 #include "chrome/browser/ui/user_manager.h"
     27 #include "chrome/common/chrome_constants.h"
     28 #include "chrome/common/chrome_switches.h"
     29 #include "chrome/common/pref_names.h"
     30 #include "chrome/common/url_constants.h"
     31 #include "chrome/test/base/in_process_browser_test.h"
     32 #include "chrome/test/base/ui_test_utils.h"
     33 #include "components/signin/core/common/profile_management_switches.h"
     34 #include "content/public/browser/web_contents.h"
     35 #include "extensions/browser/app_window/app_window_registry.h"
     36 #include "extensions/common/extension.h"
     37 #include "extensions/test/extension_test_message_listener.h"
     38 #include "net/test/embedded_test_server/embedded_test_server.h"
     39 
     40 namespace {
     41 
     42 GURL g_open_shortcut_url = GURL::EmptyGURL();
     43 
     44 }  // namespace
     45 
     46 @interface TestOpenShortcutOnStartup : NSObject
     47 - (void)applicationWillFinishLaunching:(NSNotification*)notification;
     48 @end
     49 
     50 @implementation TestOpenShortcutOnStartup
     51 
     52 - (void)applicationWillFinishLaunching:(NSNotification*)notification {
     53   if (!g_open_shortcut_url.is_valid())
     54     return;
     55 
     56   AppController* controller =
     57       base::mac::ObjCCast<AppController>([NSApp delegate]);
     58   Method getUrl = class_getInstanceMethod([controller class],
     59       @selector(getUrl:withReply:));
     60 
     61   if (getUrl == nil)
     62     return;
     63 
     64   base::scoped_nsobject<NSAppleEventDescriptor> shortcutEvent(
     65       [[NSAppleEventDescriptor alloc]
     66           initWithEventClass:kASAppleScriptSuite
     67                      eventID:kASSubroutineEvent
     68             targetDescriptor:nil
     69                     returnID:kAutoGenerateReturnID
     70                transactionID:kAnyTransactionID]);
     71   NSString* url =
     72       [NSString stringWithUTF8String:g_open_shortcut_url.spec().c_str()];
     73   [shortcutEvent setParamDescriptor:
     74       [NSAppleEventDescriptor descriptorWithString:url]
     75                          forKeyword:keyDirectObject];
     76 
     77   method_invoke(controller, getUrl, shortcutEvent.get(), NULL);
     78 }
     79 
     80 @end
     81 
     82 namespace {
     83 
     84 class AppControllerPlatformAppBrowserTest
     85     : public extensions::PlatformAppBrowserTest {
     86  protected:
     87   AppControllerPlatformAppBrowserTest()
     88       : active_browser_list_(BrowserList::GetInstance(
     89                                 chrome::GetActiveDesktop())) {
     90   }
     91 
     92   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     93     PlatformAppBrowserTest::SetUpCommandLine(command_line);
     94     command_line->AppendSwitchASCII(switches::kAppId,
     95                                     "1234");
     96   }
     97 
     98   const BrowserList* active_browser_list_;
     99 };
    100 
    101 // Test that if only a platform app window is open and no browser windows are
    102 // open then a reopen event does nothing.
    103 IN_PROC_BROWSER_TEST_F(AppControllerPlatformAppBrowserTest,
    104                        PlatformAppReopenWithWindows) {
    105   base::scoped_nsobject<AppController> ac([[AppController alloc] init]);
    106   NSUInteger old_window_count = [[NSApp windows] count];
    107   EXPECT_EQ(1u, active_browser_list_->size());
    108   [ac applicationShouldHandleReopen:NSApp hasVisibleWindows:YES];
    109   // We do not EXPECT_TRUE the result here because the method
    110   // deminiaturizes windows manually rather than return YES and have
    111   // AppKit do it.
    112 
    113   EXPECT_EQ(old_window_count, [[NSApp windows] count]);
    114   EXPECT_EQ(1u, active_browser_list_->size());
    115 }
    116 
    117 IN_PROC_BROWSER_TEST_F(AppControllerPlatformAppBrowserTest,
    118                        ActivationFocusesBrowserWindow) {
    119   base::scoped_nsobject<AppController> app_controller(
    120       [[AppController alloc] init]);
    121 
    122   ExtensionTestMessageListener listener("Launched", false);
    123   const extensions::Extension* app =
    124       InstallAndLaunchPlatformApp("minimal");
    125   ASSERT_TRUE(listener.WaitUntilSatisfied());
    126 
    127   NSWindow* app_window = extensions::AppWindowRegistry::Get(profile())
    128                              ->GetAppWindowsForApp(app->id())
    129                              .front()
    130                              ->GetNativeWindow();
    131   NSWindow* browser_window = browser()->window()->GetNativeWindow();
    132 
    133   EXPECT_LE([[NSApp orderedWindows] indexOfObject:app_window],
    134             [[NSApp orderedWindows] indexOfObject:browser_window]);
    135   [app_controller applicationShouldHandleReopen:NSApp
    136                               hasVisibleWindows:YES];
    137   EXPECT_LE([[NSApp orderedWindows] indexOfObject:browser_window],
    138             [[NSApp orderedWindows] indexOfObject:app_window]);
    139 }
    140 
    141 class AppControllerWebAppBrowserTest : public InProcessBrowserTest {
    142  protected:
    143   AppControllerWebAppBrowserTest()
    144       : active_browser_list_(BrowserList::GetInstance(
    145                                 chrome::GetActiveDesktop())) {
    146   }
    147 
    148   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    149     command_line->AppendSwitchASCII(switches::kApp, GetAppURL());
    150   }
    151 
    152   std::string GetAppURL() const {
    153     return "http://example.com/";
    154   }
    155 
    156   const BrowserList* active_browser_list_;
    157 };
    158 
    159 // Test that in web app mode a reopen event opens the app URL.
    160 IN_PROC_BROWSER_TEST_F(AppControllerWebAppBrowserTest,
    161                        WebAppReopenWithNoWindows) {
    162   base::scoped_nsobject<AppController> ac([[AppController alloc] init]);
    163   EXPECT_EQ(1u, active_browser_list_->size());
    164   BOOL result = [ac applicationShouldHandleReopen:NSApp hasVisibleWindows:NO];
    165 
    166   EXPECT_FALSE(result);
    167   EXPECT_EQ(2u, active_browser_list_->size());
    168 
    169   Browser* browser = active_browser_list_->get(0);
    170   GURL current_url =
    171       browser->tab_strip_model()->GetActiveWebContents()->GetURL();
    172   EXPECT_EQ(GetAppURL(), current_url.spec());
    173 }
    174 
    175 // Called when the ProfileManager has created a profile.
    176 void CreateProfileCallback(const base::Closure& quit_closure,
    177                            Profile* profile,
    178                            Profile::CreateStatus status) {
    179   EXPECT_TRUE(profile);
    180   EXPECT_NE(Profile::CREATE_STATUS_LOCAL_FAIL, status);
    181   EXPECT_NE(Profile::CREATE_STATUS_REMOTE_FAIL, status);
    182   // This will be called multiple times. Wait until the profile is initialized
    183   // fully to quit the loop.
    184   if (status == Profile::CREATE_STATUS_INITIALIZED)
    185     quit_closure.Run();
    186 }
    187 
    188 void CreateAndWaitForGuestProfile() {
    189   ProfileManager::CreateCallback create_callback =
    190       base::Bind(&CreateProfileCallback,
    191                  base::MessageLoop::current()->QuitClosure());
    192   g_browser_process->profile_manager()->CreateProfileAsync(
    193       ProfileManager::GetGuestProfilePath(),
    194       create_callback,
    195       base::string16(),
    196       base::string16(),
    197       std::string());
    198   base::RunLoop().Run();
    199 }
    200 
    201 class AppControllerNewProfileManagementBrowserTest
    202     : public InProcessBrowserTest {
    203  protected:
    204   AppControllerNewProfileManagementBrowserTest()
    205       : active_browser_list_(BrowserList::GetInstance(
    206                                 chrome::GetActiveDesktop())) {
    207   }
    208 
    209   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    210     switches::EnableNewProfileManagementForTesting(command_line);
    211   }
    212 
    213   const BrowserList* active_browser_list_;
    214 };
    215 
    216 // Test that for a regular last profile, a reopen event opens a browser.
    217 IN_PROC_BROWSER_TEST_F(AppControllerNewProfileManagementBrowserTest,
    218                        RegularProfileReopenWithNoWindows) {
    219   base::scoped_nsobject<AppController> ac([[AppController alloc] init]);
    220   EXPECT_EQ(1u, active_browser_list_->size());
    221   BOOL result = [ac applicationShouldHandleReopen:NSApp hasVisibleWindows:NO];
    222 
    223   EXPECT_FALSE(result);
    224   EXPECT_EQ(2u, active_browser_list_->size());
    225   EXPECT_FALSE(UserManager::IsShowing());
    226 }
    227 
    228 // Test that for a locked last profile, a reopen event opens the User Manager.
    229 IN_PROC_BROWSER_TEST_F(AppControllerNewProfileManagementBrowserTest,
    230                        LockedProfileReopenWithNoWindows) {
    231   // The User Manager uses the guest profile as its underlying profile. To
    232   // minimize flakiness due to the scheduling/descheduling of tasks on the
    233   // different threads, pre-initialize the guest profile before it is needed.
    234   CreateAndWaitForGuestProfile();
    235   base::scoped_nsobject<AppController> ac([[AppController alloc] init]);
    236 
    237   // Lock the active profile.
    238   Profile* profile = [ac lastProfile];
    239   ProfileInfoCache& cache =
    240       g_browser_process->profile_manager()->GetProfileInfoCache();
    241   size_t profile_index = cache.GetIndexOfProfileWithPath(profile->GetPath());
    242   cache.SetProfileSigninRequiredAtIndex(profile_index, true);
    243   EXPECT_TRUE(cache.ProfileIsSigninRequiredAtIndex(profile_index));
    244 
    245   EXPECT_EQ(1u, active_browser_list_->size());
    246   BOOL result = [ac applicationShouldHandleReopen:NSApp hasVisibleWindows:NO];
    247   EXPECT_FALSE(result);
    248 
    249   base::RunLoop().RunUntilIdle();
    250   EXPECT_EQ(1u, active_browser_list_->size());
    251   EXPECT_TRUE(UserManager::IsShowing());
    252   UserManager::Hide();
    253 }
    254 
    255 // Test that for a guest last profile, a reopen event opens the User Manager.
    256 IN_PROC_BROWSER_TEST_F(AppControllerNewProfileManagementBrowserTest,
    257                        GuestProfileReopenWithNoWindows) {
    258   // Create the guest profile, and set it as the last used profile so the
    259   // app controller can use it on init.
    260   CreateAndWaitForGuestProfile();
    261   PrefService* local_state = g_browser_process->local_state();
    262   local_state->SetString(prefs::kProfileLastUsed, chrome::kGuestProfileDir);
    263 
    264   base::scoped_nsobject<AppController> ac([[AppController alloc] init]);
    265 
    266   Profile* profile = [ac lastProfile];
    267   EXPECT_EQ(ProfileManager::GetGuestProfilePath(), profile->GetPath());
    268   EXPECT_TRUE(profile->IsGuestSession());
    269 
    270   EXPECT_EQ(1u, active_browser_list_->size());
    271   BOOL result = [ac applicationShouldHandleReopen:NSApp hasVisibleWindows:NO];
    272   EXPECT_FALSE(result);
    273 
    274   base::RunLoop().RunUntilIdle();
    275 
    276   EXPECT_EQ(1u, active_browser_list_->size());
    277   EXPECT_TRUE(UserManager::IsShowing());
    278   UserManager::Hide();
    279 }
    280 
    281 class AppControllerOpenShortcutBrowserTest : public InProcessBrowserTest {
    282  protected:
    283   AppControllerOpenShortcutBrowserTest() {
    284   }
    285 
    286   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
    287     // In order to mimic opening shortcut during browser startup, we need to
    288     // send the event before -applicationDidFinishLaunching is called, but
    289     // after AppController is loaded.
    290     //
    291     // Since -applicationWillFinishLaunching does nothing now, we swizzle it to
    292     // our function to send the event. We need to do this early before running
    293     // the main message loop.
    294     //
    295     // NSApp does not exist yet. We need to get the AppController using
    296     // reflection.
    297     Class appControllerClass = NSClassFromString(@"AppController");
    298     Class openShortcutClass = NSClassFromString(@"TestOpenShortcutOnStartup");
    299 
    300     ASSERT_TRUE(appControllerClass != nil);
    301     ASSERT_TRUE(openShortcutClass != nil);
    302 
    303     SEL targetMethod = @selector(applicationWillFinishLaunching:);
    304     Method original = class_getInstanceMethod(appControllerClass,
    305         targetMethod);
    306     Method destination = class_getInstanceMethod(openShortcutClass,
    307         targetMethod);
    308 
    309     ASSERT_TRUE(original != NULL);
    310     ASSERT_TRUE(destination != NULL);
    311 
    312     method_exchangeImplementations(original, destination);
    313 
    314     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
    315     g_open_shortcut_url = embedded_test_server()->GetURL("/simple.html");
    316   }
    317 
    318   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    319     // If the arg is empty, PrepareTestCommandLine() after this function will
    320     // append about:blank as default url.
    321     command_line->AppendArg(chrome::kChromeUINewTabURL);
    322   }
    323 };
    324 
    325 IN_PROC_BROWSER_TEST_F(AppControllerOpenShortcutBrowserTest,
    326                        OpenShortcutOnStartup) {
    327   EXPECT_EQ(1, browser()->tab_strip_model()->count());
    328   EXPECT_EQ(g_open_shortcut_url,
    329       browser()->tab_strip_model()->GetActiveWebContents()
    330           ->GetLastCommittedURL());
    331 }
    332 
    333 }  // namespace
    334