ash/system/chromeos/multi_user/user_switch_util_unittest.cc

   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   ~TrySwitchingUserTest() override {}
  28
  29   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