chrome/browser/extensions/api/idle/idle_api_unittest.cc

   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/extensions/api/idle/idle_api.h"
   6
   7 #include <limits.h>
   8 #include <string>
   9
  10 #include "base/strings/string_number_conversions.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/extensions/api/idle/idle_api_constants.h"
  13 #include "chrome/browser/extensions/api/idle/idle_manager.h"
  14 #include "chrome/browser/extensions/api/idle/idle_manager_factory.h"
  15 #include "chrome/browser/extensions/extension_api_unittest.h"
  16 #include "chrome/common/extensions/api/idle.h"
  17 #include "content/public/browser/notification_details.h"
  18 #include "content/public/browser/notification_source.h"
  19 #include "extensions/browser/event_router.h"
  20 #include "extensions/browser/extension_registry.h"
  21 #include "extensions/common/extension.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using ::testing::_;
  26
  27 namespace idle = extensions::api::idle;
  28
  29 namespace extensions {
  30
  31 namespace {
  32
  33 class MockEventDelegate : public IdleManager::EventDelegate {
  34  public:
  35   MockEventDelegate() {}
  36   virtual ~MockEventDelegate() {}
  37   MOCK_METHOD2(OnStateChanged, void(const std::string&, IdleState));
  38   virtual void RegisterObserver(EventRouter::Observer* observer) {}
  39   virtual void UnregisterObserver(EventRouter::Observer* observer) {}
  40 };
  41
  42 class TestIdleProvider : public IdleManager::IdleTimeProvider {
  43  public:
  44   TestIdleProvider();
  45   ~TestIdleProvider() override;
  46   void CalculateIdleState(int idle_threshold, IdleCallback notify) override;
  47   void CalculateIdleTime(IdleTimeCallback notify) override;
  48   bool CheckIdleStateIsLocked() override;
  49
  50   void set_idle_time(int idle_time);
  51   void set_locked(bool locked);
  52
  53  private:
  54   int idle_time_;
  55   bool locked_;
  56 };
  57
  58 TestIdleProvider::TestIdleProvider()
  59     : idle_time_(0),
  60       locked_(false) {
  61 }
  62
  63 TestIdleProvider::~TestIdleProvider() {
  64 }
  65
  66 void TestIdleProvider::CalculateIdleState(int idle_threshold,
  67                                           IdleCallback notify) {
  68   if (locked_) {
  69     notify.Run(IDLE_STATE_LOCKED);
  70   } else {
  71     if (idle_time_ >= idle_threshold) {
  72       notify.Run(IDLE_STATE_IDLE);
  73     } else {
  74       notify.Run(IDLE_STATE_ACTIVE);
  75     }
  76   }
  77 }
  78
  79 void TestIdleProvider::CalculateIdleTime(IdleTimeCallback notify) {
  80   notify.Run(idle_time_);
  81 }
  82
  83 bool TestIdleProvider::CheckIdleStateIsLocked() {
  84   return locked_;
  85 }
  86
  87 void TestIdleProvider::set_idle_time(int idle_time) {
  88   idle_time_ = idle_time;
  89 }
  90
  91 void TestIdleProvider::set_locked(bool locked) {
  92   locked_ = locked;
  93 }
  94
  95 class ScopedListen {
  96  public:
  97   ScopedListen(IdleManager* idle_manager, const std::string& extension_id);
  98   ~ScopedListen();
  99
 100  private:
 101   IdleManager* idle_manager_;
 102   const std::string extension_id_;
 103 };
 104
 105 ScopedListen::ScopedListen(IdleManager* idle_manager,
 106                            const std::string& extension_id)
 107     : idle_manager_(idle_manager),
 108       extension_id_(extension_id) {
 109   const EventListenerInfo details(
 110       idle::OnStateChanged::kEventName, extension_id_, GURL(), NULL);
 111   idle_manager_->OnListenerAdded(details);
 112 }
 113
 114 ScopedListen::~ScopedListen() {
 115   const EventListenerInfo details(
 116       idle::OnStateChanged::kEventName, extension_id_, GURL(), NULL);
 117   idle_manager_->OnListenerRemoved(details);
 118 }
 119
 120 KeyedService* IdleManagerTestFactory(content::BrowserContext* context) {
 121   return new IdleManager(context);
 122 }
 123
 124 }  // namespace
 125
 126 // TODO(derat): Make this instead derive from extensions::ApiUnitTest after
 127 // moving it out of the unit_tests target. Its base class can't be changed
 128 // before then since doing so results in crashes due to multiple
 129 // content::NotificationService instances being created.
 130 class IdleTest : public ExtensionApiUnittest {
 131  public:
 132   void SetUp() override;
 133
 134  protected:
 135   IdleManager* idle_manager_;
 136   TestIdleProvider* idle_provider_;
 137   testing::StrictMock<MockEventDelegate>* event_delegate_;
 138 };
 139
 140 void IdleTest::SetUp() {
 141   ExtensionApiUnittest::SetUp();
 142
 143   IdleManagerFactory::GetInstance()->SetTestingFactory(browser()->profile(),
 144                                                        &IdleManagerTestFactory);
 145   idle_manager_ = IdleManagerFactory::GetForBrowserContext(
 146       browser()->profile());
 147
 148   idle_provider_ = new TestIdleProvider();
 149   idle_manager_->SetIdleTimeProviderForTest(
 150       scoped_ptr<IdleManager::IdleTimeProvider>(idle_provider_).Pass());
 151   event_delegate_ = new testing::StrictMock<MockEventDelegate>();
 152   idle_manager_->SetEventDelegateForTest(
 153       scoped_ptr<IdleManager::EventDelegate>(event_delegate_).Pass());
 154   idle_manager_->Init();
 155 }
 156
 157 // Verifies that "locked" takes priority over "active".
 158 TEST_F(IdleTest, QueryLockedActive) {
 159   idle_provider_->set_locked(true);
 160   idle_provider_->set_idle_time(0);
 161
 162   scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 163       new IdleQueryStateFunction(),
 164       "[60]"));
 165
 166   std::string idle_state;
 167   ASSERT_TRUE(result->GetAsString(&idle_state));
 168   EXPECT_EQ("locked", idle_state);
 169 }
 170
 171 // Verifies that "locked" takes priority over "idle".
 172 TEST_F(IdleTest, QueryLockedIdle) {
 173   idle_provider_->set_locked(true);
 174   idle_provider_->set_idle_time(INT_MAX);
 175
 176   scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 177       new IdleQueryStateFunction(),
 178       "[60]"));
 179
 180   std::string idle_state;
 181   ASSERT_TRUE(result->GetAsString(&idle_state));
 182   EXPECT_EQ("locked", idle_state);
 183 }
 184
 185 // Verifies that any amount of idle time less than the detection interval
 186 // translates to a state of "active".
 187 TEST_F(IdleTest, QueryActive) {
 188   idle_provider_->set_locked(false);
 189
 190   for (int time = 0; time < 60; ++time) {
 191     SCOPED_TRACE(time);
 192     idle_provider_->set_idle_time(time);
 193
 194     scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 195         new IdleQueryStateFunction(),
 196         "[60]"));
 197
 198     std::string idle_state;
 199     ASSERT_TRUE(result->GetAsString(&idle_state));
 200     EXPECT_EQ("active", idle_state);
 201   }
 202 }
 203
 204 // Verifies that an idle time >= the detection interval returns the "idle"
 205 // state.
 206 TEST_F(IdleTest, QueryIdle) {
 207   idle_provider_->set_locked(false);
 208
 209   for (int time = 80; time >= 60; --time) {
 210     SCOPED_TRACE(time);
 211     idle_provider_->set_idle_time(time);
 212
 213     scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 214         new IdleQueryStateFunction(),
 215         "[60]"));
 216
 217     std::string idle_state;
 218     ASSERT_TRUE(result->GetAsString(&idle_state));
 219     EXPECT_EQ("idle", idle_state);
 220   }
 221 }
 222
 223 // Verifies that requesting a detection interval < 15 has the same effect as
 224 // passing in 15.
 225 TEST_F(IdleTest, QueryMinThreshold) {
 226   idle_provider_->set_locked(false);
 227
 228   for (int threshold = 0; threshold < 20; ++threshold) {
 229     for (int time = 10; time < 60; ++time) {
 230       SCOPED_TRACE(threshold);
 231       SCOPED_TRACE(time);
 232       idle_provider_->set_idle_time(time);
 233
 234       std::string args = "[" + base::IntToString(threshold) + "]";
 235       scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 236           new IdleQueryStateFunction(), args));
 237
 238       std::string idle_state;
 239       ASSERT_TRUE(result->GetAsString(&idle_state));
 240
 241       int real_threshold = (threshold < 15) ? 15 : threshold;
 242       const char* expected = (time < real_threshold) ? "active" : "idle";
 243       EXPECT_EQ(expected, idle_state);
 244     }
 245   }
 246 }
 247
 248 // Verifies that passing in a detection interval > 4 hours has the same effect
 249 // as passing in 4 hours.
 250 TEST_F(IdleTest, QueryMaxThreshold) {
 251   idle_provider_->set_locked(false);
 252
 253   const int kFourHoursInSeconds = 4*60*60;
 254
 255   for (int threshold = kFourHoursInSeconds - 20;
 256        threshold < (kFourHoursInSeconds + 20); ++threshold) {
 257     for (int time = kFourHoursInSeconds - 30; time < kFourHoursInSeconds + 30;
 258          ++time) {
 259       SCOPED_TRACE(threshold);
 260       SCOPED_TRACE(time);
 261       idle_provider_->set_idle_time(time);
 262
 263       std::string args = "[" + base::IntToString(threshold) + "]";
 264       scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 265           new IdleQueryStateFunction(), args));
 266
 267       std::string idle_state;
 268       ASSERT_TRUE(result->GetAsString(&idle_state));
 269
 270       int real_threshold = (threshold > kFourHoursInSeconds) ?
 271           kFourHoursInSeconds : threshold;
 272       const char* expected = (time < real_threshold) ? "active" : "idle";
 273       EXPECT_EQ(expected, idle_state);
 274     }
 275   }
 276 }
 277
 278 // Verifies that transitioning from an active to idle state fires an "idle"
 279 // OnStateChanged event.
 280 TEST_F(IdleTest, ActiveToIdle) {
 281   ScopedListen listen_test(idle_manager_, "test");
 282
 283   idle_provider_->set_locked(false);
 284
 285   for (int time = 0; time < 60; ++time) {
 286     SCOPED_TRACE(time);
 287     idle_provider_->set_idle_time(time);
 288
 289     idle_manager_->UpdateIdleState();
 290   }
 291
 292   idle_provider_->set_idle_time(60);
 293
 294   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
 295   idle_manager_->UpdateIdleState();
 296   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 297
 298   for (int time = 61; time < 75; ++time) {
 299     SCOPED_TRACE(time);
 300     idle_provider_->set_idle_time(time);
 301     idle_manager_->UpdateIdleState();
 302   }
 303 }
 304
 305 // Verifies that locking an active system generates a "locked" event.
 306 TEST_F(IdleTest, ActiveToLocked) {
 307   ScopedListen listen_test(idle_manager_, "test");
 308
 309   idle_provider_->set_locked(true);
 310   idle_provider_->set_idle_time(5);
 311
 312   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
 313   idle_manager_->UpdateIdleState();
 314 }
 315
 316 // Verifies that transitioning from an idle to active state generates an
 317 // "active" event.
 318 TEST_F(IdleTest, IdleToActive) {
 319   ScopedListen listen_test(idle_manager_, "test");
 320
 321   idle_provider_->set_locked(false);
 322   idle_provider_->set_idle_time(75);
 323   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
 324   idle_manager_->UpdateIdleState();
 325   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 326
 327   idle_provider_->set_idle_time(0);
 328   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_ACTIVE));
 329   idle_manager_->UpdateIdleState();
 330 }
 331
 332 // Verifies that locking an idle system generates a "locked" event.
 333 TEST_F(IdleTest, IdleToLocked) {
 334   ScopedListen listen_test(idle_manager_, "test");
 335
 336   idle_provider_->set_locked(false);
 337   idle_provider_->set_idle_time(75);
 338
 339   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
 340   idle_manager_->UpdateIdleState();
 341   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 342
 343   idle_provider_->set_locked(true);
 344   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
 345   idle_manager_->UpdateIdleState();
 346 }
 347
 348 // Verifies that unlocking an active system generates an "active" event.
 349 TEST_F(IdleTest, LockedToActive) {
 350   ScopedListen listen_test(idle_manager_, "test");
 351
 352   idle_provider_->set_locked(true);
 353   idle_provider_->set_idle_time(0);
 354
 355   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
 356   idle_manager_->UpdateIdleState();
 357
 358   idle_provider_->set_locked(false);
 359   idle_provider_->set_idle_time(5);
 360   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_ACTIVE));
 361   idle_manager_->UpdateIdleState();
 362 }
 363
 364 // Verifies that unlocking an inactive system generates an "idle" event.
 365 TEST_F(IdleTest, LockedToIdle) {
 366   ScopedListen listen_test(idle_manager_, "test");
 367
 368   idle_provider_->set_locked(true);
 369   idle_provider_->set_idle_time(75);
 370   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
 371   idle_manager_->UpdateIdleState();
 372   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 373
 374   idle_provider_->set_locked(false);
 375   EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
 376   idle_manager_->UpdateIdleState();
 377 }
 378
 379 // Verifies that events are routed to extensions that have one or more listeners
 380 // in scope.
 381 TEST_F(IdleTest, MultipleExtensions) {
 382   ScopedListen listen_1(idle_manager_, "1");
 383   ScopedListen listen_2(idle_manager_, "2");
 384
 385   idle_provider_->set_locked(true);
 386   EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_LOCKED));
 387   EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_LOCKED));
 388   idle_manager_->UpdateIdleState();
 389   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 390
 391   {
 392     ScopedListen listen_2prime(idle_manager_, "2");
 393     ScopedListen listen_3(idle_manager_, "3");
 394     idle_provider_->set_locked(false);
 395     EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_ACTIVE));
 396     EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_ACTIVE));
 397     EXPECT_CALL(*event_delegate_, OnStateChanged("3", IDLE_STATE_ACTIVE));
 398     idle_manager_->UpdateIdleState();
 399     testing::Mock::VerifyAndClearExpectations(event_delegate_);
 400   }
 401
 402   idle_provider_->set_locked(true);
 403   EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_LOCKED));
 404   EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_LOCKED));
 405   idle_manager_->UpdateIdleState();
 406 }
 407
 408 // Verifies that setDetectionInterval changes the detection interval from the
 409 // default of 60 seconds, and that the call only affects a single extension's
 410 // IdleMonitor.
 411 TEST_F(IdleTest, SetDetectionInterval) {
 412   ScopedListen listen_default(idle_manager_, "default");
 413   ScopedListen listen_extension(idle_manager_, extension()->id());
 414
 415   scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
 416       new IdleSetDetectionIntervalFunction(),
 417       "[45]"));
 418
 419   idle_provider_->set_locked(false);
 420   idle_provider_->set_idle_time(44);
 421   idle_manager_->UpdateIdleState();
 422
 423   idle_provider_->set_idle_time(45);
 424   EXPECT_CALL(*event_delegate_,
 425               OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 426   idle_manager_->UpdateIdleState();
 427   // Verify that the expectation has been fulfilled before incrementing the
 428   // time again.
 429   testing::Mock::VerifyAndClearExpectations(event_delegate_);
 430
 431   idle_provider_->set_idle_time(60);
 432   EXPECT_CALL(*event_delegate_, OnStateChanged("default", IDLE_STATE_IDLE));
 433   idle_manager_->UpdateIdleState();
 434 }
 435
 436 // Verifies that setting the detection interval before creating the listener
 437 // works correctly.
 438 TEST_F(IdleTest, SetDetectionIntervalBeforeListener) {
 439   scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
 440       new IdleSetDetectionIntervalFunction(),
 441       "[45]"));
 442
 443   ScopedListen listen_extension(idle_manager_, extension()->id());
 444
 445   idle_provider_->set_locked(false);
 446   idle_provider_->set_idle_time(44);
 447   idle_manager_->UpdateIdleState();
 448
 449   idle_provider_->set_idle_time(45);
 450   EXPECT_CALL(*event_delegate_,
 451               OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 452   idle_manager_->UpdateIdleState();
 453 }
 454
 455 // Verifies that setting a detection interval above the maximum value results
 456 // in an interval of 4 hours.
 457 TEST_F(IdleTest, SetDetectionIntervalMaximum) {
 458   ScopedListen listen_extension(idle_manager_, extension()->id());
 459
 460   scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 461       new IdleSetDetectionIntervalFunction(),
 462       "[18000]"));  // five hours in seconds
 463
 464   idle_provider_->set_locked(false);
 465   idle_provider_->set_idle_time(4*60*60 - 1);
 466   idle_manager_->UpdateIdleState();
 467
 468   idle_provider_->set_idle_time(4*60*60);
 469   EXPECT_CALL(*event_delegate_,
 470               OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 471   idle_manager_->UpdateIdleState();
 472 }
 473
 474 // Verifies that setting a detection interval below the minimum value results
 475 // in an interval of 15 seconds.
 476 TEST_F(IdleTest, SetDetectionIntervalMinimum) {
 477   ScopedListen listen_extension(idle_manager_, extension()->id());
 478
 479   scoped_ptr<base::Value> result(RunFunctionAndReturnValue(
 480       new IdleSetDetectionIntervalFunction(),
 481       "[10]"));
 482
 483   idle_provider_->set_locked(false);
 484   idle_provider_->set_idle_time(14);
 485   idle_manager_->UpdateIdleState();
 486
 487   idle_provider_->set_idle_time(15);
 488   EXPECT_CALL(*event_delegate_,
 489               OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 490   idle_manager_->UpdateIdleState();
 491 }
 492
 493 // Verifies that an extension's detection interval is discarded when it unloads.
 494 TEST_F(IdleTest, UnloadCleanup) {
 495   {
 496     ScopedListen listen(idle_manager_, extension()->id());
 497
 498     scoped_ptr<base::Value> result45(RunFunctionAndReturnValue(
 499         new IdleSetDetectionIntervalFunction(),
 500         "[15]"));
 501   }
 502
 503   // Listener count dropping to zero does not reset threshold.
 504
 505   {
 506     ScopedListen listen(idle_manager_, extension()->id());
 507     idle_provider_->set_idle_time(16);
 508     EXPECT_CALL(*event_delegate_,
 509                 OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 510     idle_manager_->UpdateIdleState();
 511     testing::Mock::VerifyAndClearExpectations(event_delegate_);
 512   }
 513
 514   // Threshold will reset after unload (and listen count == 0)
 515   ExtensionRegistry* registry = ExtensionRegistry::Get(browser()->profile());
 516   registry->TriggerOnUnloaded(extension(),
 517                               UnloadedExtensionInfo::REASON_UNINSTALL);
 518
 519   {
 520     ScopedListen listen(idle_manager_, extension()->id());
 521     idle_manager_->UpdateIdleState();
 522     testing::Mock::VerifyAndClearExpectations(event_delegate_);
 523
 524     idle_provider_->set_idle_time(61);
 525     EXPECT_CALL(*event_delegate_,
 526                 OnStateChanged(extension()->id(), IDLE_STATE_IDLE));
 527     idle_manager_->UpdateIdleState();
 528   }
 529 }
 530
 531 // Verifies that unloading an extension with no listeners or threshold works.
 532 TEST_F(IdleTest, UnloadOnly) {
 533   ExtensionRegistry* registry = ExtensionRegistry::Get(browser()->profile());
 534   registry->TriggerOnUnloaded(extension(),
 535                               UnloadedExtensionInfo::REASON_UNINSTALL);
 536 }
 537
 538 // Verifies that its ok for the unload notification to happen before all the
 539 // listener removals.
 540 TEST_F(IdleTest, UnloadWhileListening) {
 541   ScopedListen listen(idle_manager_, extension()->id());
 542   ExtensionRegistry* registry = ExtensionRegistry::Get(browser()->profile());
 543   registry->TriggerOnUnloaded(extension(),
 544                               UnloadedExtensionInfo::REASON_UNINSTALL);
 545 }
 546
 547 // Verifies that re-adding a listener after a state change doesn't immediately
 548 // fire a change event. Regression test for http://crbug.com/366580.
 549 TEST_F(IdleTest, ReAddListener) {
 550   idle_provider_->set_locked(false);
 551
 552   {
 553     // Fire idle event.
 554     ScopedListen listen(idle_manager_, "test");
 555     idle_provider_->set_idle_time(60);
 556     EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
 557     idle_manager_->UpdateIdleState();
 558     testing::Mock::VerifyAndClearExpectations(event_delegate_);
 559   }
 560
 561   // Trigger active.
 562   idle_provider_->set_idle_time(0);
 563   idle_manager_->UpdateIdleState();
 564
 565   {
 566     // Nothing should have fired, the listener wasn't added until afterward.
 567     ScopedListen listen(idle_manager_, "test");
 568     idle_manager_->UpdateIdleState();
 569     testing::Mock::VerifyAndClearExpectations(event_delegate_);
 570   }
 571 }
 572
 573 }  // namespace extensions