Home | History | Annotate | Download | only in multi_user 
      1 // Copyright 2014 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 "ash/shell.h"
      6 #include "ash/system/chromeos/multi_user/user_switch_util.h"
      7 #include "ash/system/chromeos/screen_security/screen_tray_item.h"
      8 #include "ash/system/tray/system_tray.h"
      9 #include "ash/test/ash_test_base.h"
     10 
     11 namespace ash {
     12 
     13 class TrySwitchingUserTest : public ash::test::AshTestBase {
     14  public:
     15   // The action type to perform / check for upon user switching.
     16   enum ActionType {
     17     NO_DIALOG,  // No dialog should be shown.
     18     ACCEPT_DIALOG,  // A dialog should be shown and we should accept it.
     19     DECLINE_DIALOG,  // A dialog should be shown and we do not accept it.
     20   };
     21   TrySwitchingUserTest()
     22       : capture_item_(NULL),
     23         share_item_(NULL),
     24         stop_capture_callback_hit_count_(0),
     25         stop_share_callback_hit_count_(0),
     26         switch_callback_hit_count_(0) {}
     27   virtual ~TrySwitchingUserTest() {}
     28 
     29   virtual void SetUp() OVERRIDE {
     30     test::AshTestBase::SetUp();
     31     TrayItemView::DisableAnimationsForTest();
     32     SystemTray* system_tray =  Shell::GetInstance()->GetPrimarySystemTray();
     33     share_item_ = system_tray->GetScreenShareItem();
     34     capture_item_ = system_tray->GetScreenCaptureItem();
     35     EXPECT_TRUE(share_item_);
     36     EXPECT_TRUE(capture_item_);
     37   }
     38 
     39   // Accessing the capture session functionality.
     40   // Simulates a screen capture session start.
     41   void StartCaptureSession() {
     42     capture_item_->Start(
     43         base::Bind(&TrySwitchingUserTest::StopCaptureCallback,
     44                    base::Unretained(this)));
     45   }
     46 
     47   // The callback which gets called when the screen capture gets stopped.
     48   void StopCaptureSession() {
     49     capture_item_->Stop();
     50   }
     51 
     52   // Simulates a screen capture session stop.
     53   void StopCaptureCallback() {
     54     stop_capture_callback_hit_count_++;
     55   }
     56 
     57   // Accessing the share session functionality.
     58   // Simulate a Screen share session start.
     59   void StartShareSession() {
     60     share_item_->Start(
     61         base::Bind(&TrySwitchingUserTest::StopShareCallback,
     62                    base::Unretained(this)));
     63   }
     64 
     65   // Simulates a screen share session stop.
     66   void StopShareSession() {
     67     share_item_->Stop();
     68   }
     69 
     70   // The callback which gets called when the screen share gets stopped.
     71   void StopShareCallback() {
     72     stop_share_callback_hit_count_++;
     73   }
     74 
     75   // Issuing a switch user call which might or might not create a dialog.
     76   // The passed |action| type parameter defines the outcome (which will be
     77   // checked) and the action the user will choose.
     78   void SwitchUser(ActionType action) {
     79     TrySwitchingActiveUser(
     80         base::Bind(&TrySwitchingUserTest::SwitchCallback,
     81                    base::Unretained(this)));
     82     switch(action) {
     83       case NO_DIALOG:
     84         EXPECT_TRUE(!TestAndTerminateDesktopCastingWarningForTest(true));
     85         return;
     86       case ACCEPT_DIALOG:
     87         EXPECT_TRUE(TestAndTerminateDesktopCastingWarningForTest(true));
     88         return;
     89       case DECLINE_DIALOG:
     90         EXPECT_TRUE(TestAndTerminateDesktopCastingWarningForTest(false));
     91         return;
     92     }
     93   }
     94 
     95   // Called when the user will get actually switched.
     96   void SwitchCallback() {
     97     switch_callback_hit_count_++;
     98   }
     99 
    100   // Various counter accessors.
    101   int stop_capture_callback_hit_count() const {
    102     return stop_capture_callback_hit_count_;
    103   }
    104   int stop_share_callback_hit_count() const {
    105     return stop_share_callback_hit_count_;
    106   }
    107   int switch_callback_hit_count() const { return switch_callback_hit_count_; }
    108 
    109  private:
    110   // The two items from the SystemTray for the screen capture / share
    111   // functionality.
    112   ScreenTrayItem* capture_item_;
    113   ScreenTrayItem* share_item_;
    114 
    115   // Various counters to query for.
    116   int stop_capture_callback_hit_count_;
    117   int stop_share_callback_hit_count_;
    118   int switch_callback_hit_count_;
    119 
    120   DISALLOW_COPY_AND_ASSIGN(TrySwitchingUserTest);
    121 };
    122 
    123 // Test that when there is no screen operation going on the user switch will be
    124 // performed as planned.
    125 TEST_F(TrySwitchingUserTest, NoLock) {
    126   EXPECT_EQ(0, switch_callback_hit_count());
    127   SwitchUser(TrySwitchingUserTest::NO_DIALOG);
    128   EXPECT_EQ(1, switch_callback_hit_count());
    129 }
    130 
    131 // Test that with a screen capture operation going on, the user will need to
    132 // confirm. Declining will neither change the running state or switch users.
    133 TEST_F(TrySwitchingUserTest, CaptureActiveDeclined) {
    134   EXPECT_EQ(0, switch_callback_hit_count());
    135   StartCaptureSession();
    136   SwitchUser(TrySwitchingUserTest::DECLINE_DIALOG);
    137   EXPECT_EQ(0, switch_callback_hit_count());
    138   EXPECT_EQ(0, stop_capture_callback_hit_count());
    139   EXPECT_EQ(0, stop_share_callback_hit_count());
    140   StopCaptureSession();
    141   EXPECT_EQ(0, switch_callback_hit_count());
    142   EXPECT_EQ(1, stop_capture_callback_hit_count());
    143   EXPECT_EQ(0, stop_share_callback_hit_count());
    144 }
    145 
    146 // Test that with a screen share operation going on, the user will need to
    147 // confirm. Declining will neither change the running state or switch users.
    148 TEST_F(TrySwitchingUserTest, ShareActiveDeclined) {
    149   EXPECT_EQ(0, switch_callback_hit_count());
    150   StartShareSession();
    151   SwitchUser(TrySwitchingUserTest::DECLINE_DIALOG);
    152   EXPECT_EQ(0, switch_callback_hit_count());
    153   EXPECT_EQ(0, stop_capture_callback_hit_count());
    154   EXPECT_EQ(0, stop_share_callback_hit_count());
    155   StopShareSession();
    156   EXPECT_EQ(0, switch_callback_hit_count());
    157   EXPECT_EQ(0, stop_capture_callback_hit_count());
    158   EXPECT_EQ(1, stop_share_callback_hit_count());
    159 }
    160 
    161 // Test that with both operations going on, the user will need to confirm.
    162 // Declining will neither change the running state or switch users.
    163 TEST_F(TrySwitchingUserTest, BothActiveDeclined) {
    164   EXPECT_EQ(0, switch_callback_hit_count());
    165   StartShareSession();
    166   StartCaptureSession();
    167   SwitchUser(TrySwitchingUserTest::DECLINE_DIALOG);
    168   EXPECT_EQ(0, switch_callback_hit_count());
    169   EXPECT_EQ(0, stop_capture_callback_hit_count());
    170   EXPECT_EQ(0, stop_share_callback_hit_count());
    171   StopShareSession();
    172   StopCaptureSession();
    173   EXPECT_EQ(0, switch_callback_hit_count());
    174   EXPECT_EQ(1, stop_capture_callback_hit_count());
    175   EXPECT_EQ(1, stop_share_callback_hit_count());
    176 }
    177 
    178 // Test that with a screen capture operation going on, the user will need to
    179 // confirm. Accepting will change to stopped state and switch users.
    180 TEST_F(TrySwitchingUserTest, CaptureActiveAccepted) {
    181   EXPECT_EQ(0, switch_callback_hit_count());
    182   StartCaptureSession();
    183   SwitchUser(TrySwitchingUserTest::ACCEPT_DIALOG);
    184   EXPECT_EQ(1, switch_callback_hit_count());
    185   EXPECT_EQ(1, stop_capture_callback_hit_count());
    186   EXPECT_EQ(0, stop_share_callback_hit_count());
    187   // Another stop should have no effect.
    188   StopCaptureSession();
    189   EXPECT_EQ(1, switch_callback_hit_count());
    190   EXPECT_EQ(1, stop_capture_callback_hit_count());
    191   EXPECT_EQ(0, stop_share_callback_hit_count());
    192 }
    193 
    194 // Test that with a screen share operation going on, the user will need to
    195 // confirm. Accepting will change to stopped state and switch users.
    196 TEST_F(TrySwitchingUserTest, ShareActiveAccepted) {
    197   EXPECT_EQ(0, switch_callback_hit_count());
    198   StartShareSession();
    199   SwitchUser(TrySwitchingUserTest::ACCEPT_DIALOG);
    200   EXPECT_EQ(1, switch_callback_hit_count());
    201   EXPECT_EQ(0, stop_capture_callback_hit_count());
    202   EXPECT_EQ(1, stop_share_callback_hit_count());
    203   // Another stop should have no effect.
    204   StopShareSession();
    205   EXPECT_EQ(1, switch_callback_hit_count());
    206   EXPECT_EQ(0, stop_capture_callback_hit_count());
    207   EXPECT_EQ(1, stop_share_callback_hit_count());
    208 }
    209 
    210 // Test that with both operations going on, the user will need to confirm.
    211 // Accepting will change to stopped state and switch users.
    212 TEST_F(TrySwitchingUserTest, BothActiveAccepted) {
    213   EXPECT_EQ(0, switch_callback_hit_count());
    214   StartShareSession();
    215   StartCaptureSession();
    216   SwitchUser(TrySwitchingUserTest::ACCEPT_DIALOG);
    217   EXPECT_EQ(1, switch_callback_hit_count());
    218   EXPECT_EQ(1, stop_capture_callback_hit_count());
    219   EXPECT_EQ(1, stop_share_callback_hit_count());
    220   // Another stop should have no effect.
    221   StopShareSession();
    222   StopCaptureSession();
    223   EXPECT_EQ(1, switch_callback_hit_count());
    224   EXPECT_EQ(1, stop_capture_callback_hit_count());
    225   EXPECT_EQ(1, stop_share_callback_hit_count());
    226 }
    227 
    228 }  // namespace ash
    229