Home | History | Annotate | Download | only in login 
      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 #include "chrome/browser/chromeos/login/screen_locker.h"
      6 
      7 #include "ash/wm/window_state.h"
      8 #include "base/command_line.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "chrome/browser/chrome_notification_types.h"
     12 #include "chrome/browser/chromeos/login/mock_authenticator.h"
     13 #include "chrome/browser/chromeos/login/screen_locker_tester.h"
     14 #include "chrome/browser/chromeos/login/user_manager.h"
     15 #include "chrome/browser/profiles/profile_manager.h"
     16 #include "chrome/browser/ui/browser.h"
     17 #include "chrome/browser/ui/browser_window.h"
     18 #include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
     19 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     20 #include "chrome/common/chrome_switches.h"
     21 #include "chrome/test/base/in_process_browser_test.h"
     22 #include "chrome/test/base/ui_test_utils.h"
     23 #include "chromeos/chromeos_switches.h"
     24 #include "chromeos/dbus/fake_dbus_thread_manager.h"
     25 #include "chromeos/dbus/fake_session_manager_client.h"
     26 #include "content/public/browser/notification_service.h"
     27 #include "testing/gmock/include/gmock/gmock.h"
     28 #include "testing/gtest/include/gtest/gtest.h"
     29 #include "ui/base/test/ui_controls.h"
     30 #include "ui/compositor/layer_animator.h"
     31 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
     32 #include "ui/views/widget/widget.h"
     33 
     34 using testing::_;
     35 using testing::AnyNumber;
     36 using testing::Return;
     37 
     38 namespace {
     39 
     40 // An object that wait for lock state and fullscreen state.
     41 class Waiter : public content::NotificationObserver {
     42  public:
     43   explicit Waiter(Browser* browser)
     44       : browser_(browser),
     45         running_(false) {
     46     registrar_.Add(this,
     47                    chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
     48                    content::NotificationService::AllSources());
     49     registrar_.Add(this,
     50                    chrome::NOTIFICATION_FULLSCREEN_CHANGED,
     51                    content::NotificationService::AllSources());
     52   }
     53 
     54   virtual ~Waiter() {
     55   }
     56 
     57   virtual void Observe(int type,
     58                        const content::NotificationSource& source,
     59                        const content::NotificationDetails& details) OVERRIDE {
     60     DCHECK(type == chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED ||
     61            type == chrome::NOTIFICATION_FULLSCREEN_CHANGED);
     62     if (running_)
     63       base::MessageLoop::current()->Quit();
     64   }
     65 
     66   // Wait until the two conditions are met.
     67   void Wait(bool locker_state, bool fullscreen) {
     68     running_ = true;
     69     scoped_ptr<chromeos::test::ScreenLockerTester>
     70         tester(chromeos::ScreenLocker::GetTester());
     71     while (tester->IsLocked() != locker_state ||
     72            browser_->window()->IsFullscreen() != fullscreen) {
     73       content::RunMessageLoop();
     74     }
     75     // Make sure all pending tasks are executed.
     76     content::RunAllPendingInMessageLoop();
     77     running_ = false;
     78   }
     79 
     80  private:
     81   Browser* browser_;
     82   content::NotificationRegistrar registrar_;
     83 
     84   // Are we currently running the message loop?
     85   bool running_;
     86 
     87   DISALLOW_COPY_AND_ASSIGN(Waiter);
     88 };
     89 
     90 }  // namespace
     91 
     92 namespace chromeos {
     93 
     94 class ScreenLockerTest : public InProcessBrowserTest {
     95  public:
     96   ScreenLockerTest() : fake_session_manager_client_(NULL) {
     97   }
     98 
     99  protected:
    100   FakeSessionManagerClient* fake_session_manager_client_;
    101 
    102   void LockScreen(test::ScreenLockerTester* tester) {
    103     ScreenLocker::Show();
    104     tester->EmulateWindowManagerReady();
    105     content::WindowedNotificationObserver lock_state_observer(
    106         chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
    107         content::NotificationService::AllSources());
    108     if (!tester->IsLocked())
    109       lock_state_observer.Wait();
    110     EXPECT_TRUE(tester->IsLocked());
    111   }
    112 
    113   // Verifies if LockScreenDismissed() was called once.
    114   bool VerifyLockScreenDismissed() {
    115     return 1 == fake_session_manager_client_->
    116                     notify_lock_screen_dismissed_call_count();
    117   }
    118 
    119  private:
    120   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
    121     FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager;
    122     fake_dbus_thread_manager->SetFakeClients();
    123     fake_session_manager_client_ = new FakeSessionManagerClient;
    124     fake_dbus_thread_manager->SetSessionManagerClient(
    125         scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
    126     DBusThreadManager::SetInstanceForTesting(fake_dbus_thread_manager);
    127 
    128     InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
    129     zero_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
    130         ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
    131   }
    132 
    133   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    134     command_line->AppendSwitchASCII(switches::kLoginProfile, "user");
    135   }
    136 
    137   scoped_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
    138 
    139   DISALLOW_COPY_AND_ASSIGN(ScreenLockerTest);
    140 };
    141 
    142 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestBasic) {
    143   ScreenLocker::Show();
    144   scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
    145   tester->EmulateWindowManagerReady();
    146   content::WindowedNotificationObserver lock_state_observer(
    147       chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED,
    148       content::NotificationService::AllSources());
    149   if (!chromeos::ScreenLocker::GetTester()->IsLocked())
    150     lock_state_observer.Wait();
    151 
    152   // Test to make sure that the widget is actually appearing and is of
    153   // reasonable size, preventing a regression of
    154   // http://code.google.com/p/chromium-os/issues/detail?id=5987
    155   gfx::Rect lock_bounds = tester->GetChildWidget()->GetWindowBoundsInScreen();
    156   EXPECT_GT(lock_bounds.width(), 10);
    157   EXPECT_GT(lock_bounds.height(), 10);
    158 
    159   tester->InjectMockAuthenticator(UserManager::kStubUser, "pass");
    160   EXPECT_TRUE(tester->IsLocked());
    161   tester->EnterPassword("fail");
    162   content::RunAllPendingInMessageLoop();
    163   EXPECT_TRUE(tester->IsLocked());
    164   tester->EnterPassword("pass");
    165   content::RunAllPendingInMessageLoop();
    166   // Successful authentication clears the lock screen and tells the
    167   // SessionManager to announce this over DBus.
    168   EXPECT_FALSE(tester->IsLocked());
    169   EXPECT_EQ(
    170       1,
    171       fake_session_manager_client_->notify_lock_screen_shown_call_count());
    172 
    173   EXPECT_TRUE(VerifyLockScreenDismissed());
    174 }
    175 
    176 // Test how locking the screen affects an active fullscreen window.
    177 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestFullscreenExit) {
    178   // 1) If the active browser window is in fullscreen and the fullscreen window
    179   // does not have all the pixels (e.g. the shelf is auto hidden instead of
    180   // hidden), locking the screen should not exit fullscreen. The shelf is
    181   // auto hidden when in immersive fullscreen.
    182   scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
    183   BrowserWindow* browser_window = browser()->window();
    184   ash::wm::WindowState* window_state = ash::wm::GetWindowState(
    185       browser_window->GetNativeWindow());
    186   {
    187     Waiter waiter(browser());
    188     browser()->fullscreen_controller()->ToggleFullscreenMode();
    189     waiter.Wait(false /* not locked */, true /* full screen */);
    190     EXPECT_TRUE(browser_window->IsFullscreen());
    191     EXPECT_FALSE(window_state->hide_shelf_when_fullscreen());
    192     EXPECT_FALSE(tester->IsLocked());
    193   }
    194   {
    195     Waiter waiter(browser());
    196     ScreenLocker::Show();
    197     tester->EmulateWindowManagerReady();
    198     waiter.Wait(true /* locked */, true /* full screen */);
    199     EXPECT_TRUE(browser_window->IsFullscreen());
    200     EXPECT_FALSE(window_state->hide_shelf_when_fullscreen());
    201     EXPECT_TRUE(tester->IsLocked());
    202   }
    203   tester->InjectMockAuthenticator(UserManager::kStubUser, "pass");
    204   tester->EnterPassword("pass");
    205   content::RunAllPendingInMessageLoop();
    206   EXPECT_FALSE(tester->IsLocked());
    207   {
    208     Waiter waiter(browser());
    209     browser()->fullscreen_controller()->ToggleFullscreenMode();
    210     waiter.Wait(false /* not locked */, false /* fullscreen */);
    211     EXPECT_FALSE(browser_window->IsFullscreen());
    212   }
    213 
    214   // 2) If the active browser window is in fullscreen and the fullscreen window
    215   // has all of the pixels, locking the screen should exit fullscreen. The
    216   // fullscreen window has all of the pixels when in tab fullscreen.
    217   {
    218     Waiter waiter(browser());
    219     content::WebContents* web_contents =
    220         browser()->tab_strip_model()->GetActiveWebContents();
    221     browser()->fullscreen_controller()->ToggleFullscreenModeForTab(
    222         web_contents, true);
    223     waiter.Wait(false /* not locked */, true /* fullscreen */);
    224     EXPECT_TRUE(browser_window->IsFullscreen());
    225     EXPECT_TRUE(window_state->hide_shelf_when_fullscreen());
    226     EXPECT_FALSE(tester->IsLocked());
    227   }
    228   {
    229     Waiter waiter(browser());
    230     ScreenLocker::Show();
    231     tester->EmulateWindowManagerReady();
    232     waiter.Wait(true /* locked */, false /* full screen */);
    233     EXPECT_FALSE(browser_window->IsFullscreen());
    234     EXPECT_TRUE(tester->IsLocked());
    235   }
    236 
    237   tester->InjectMockAuthenticator(UserManager::kStubUser, "pass");
    238   tester->EnterPassword("pass");
    239   content::RunAllPendingInMessageLoop();
    240   EXPECT_FALSE(tester->IsLocked());
    241 
    242   EXPECT_EQ(
    243       2,
    244       fake_session_manager_client_->notify_lock_screen_shown_call_count());
    245   EXPECT_EQ(
    246       2,
    247       fake_session_manager_client_->notify_lock_screen_dismissed_call_count());
    248 }
    249 
    250 void SimulateKeyPress(views::Widget* widget, ui::KeyboardCode key_code) {
    251   ui_controls::SendKeyPress(widget->GetNativeWindow(),
    252                             key_code, false, false, false, false);
    253 }
    254 
    255 void UnlockKeyPress(views::Widget* widget) {
    256   SimulateKeyPress(widget, ui::VKEY_SPACE);
    257 }
    258 
    259 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, TestShowTwice) {
    260   scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
    261   LockScreen(tester.get());
    262 
    263   // Calling Show again simply send LockCompleted signal.
    264   ScreenLocker::Show();
    265   EXPECT_TRUE(tester->IsLocked());
    266   EXPECT_EQ(
    267       2,
    268       fake_session_manager_client_->notify_lock_screen_shown_call_count());
    269 
    270 
    271   // Close the locker to match expectations.
    272   ScreenLocker::Hide();
    273   content::RunAllPendingInMessageLoop();
    274   EXPECT_FALSE(tester->IsLocked());
    275   EXPECT_TRUE(VerifyLockScreenDismissed());
    276 }
    277 
    278 // TODO(flackr): Find out why the RenderView isn't getting the escape press
    279 // and re-enable this test (currently this test is flaky).
    280 IN_PROC_BROWSER_TEST_F(ScreenLockerTest, DISABLED_TestEscape) {
    281   scoped_ptr<test::ScreenLockerTester> tester(ScreenLocker::GetTester());
    282   LockScreen(tester.get());
    283 
    284   EXPECT_EQ(
    285       1,
    286       fake_session_manager_client_->notify_lock_screen_shown_call_count());
    287 
    288   tester->SetPassword("password");
    289   EXPECT_EQ("password", tester->GetPassword());
    290   // Escape clears the password.
    291   SimulateKeyPress(tester->GetWidget(), ui::VKEY_ESCAPE);
    292   content::RunAllPendingInMessageLoop();
    293   EXPECT_EQ("", tester->GetPassword());
    294 
    295   // Close the locker to match expectations.
    296   ScreenLocker::Hide();
    297   content::RunAllPendingInMessageLoop();
    298   EXPECT_FALSE(tester->IsLocked());
    299   EXPECT_TRUE(VerifyLockScreenDismissed());
    300 }
    301 
    302 }  // namespace chromeos
    303