Eliminate the cooldown for direct calls to on-demand updates in CUS.

chrome/browser/component_updater/test/component_updater_service_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/component_updater/test/component_updater_service_unittest.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 669 matching lines @@
           "version=\"0.9\" installsource=\"ondemand\"><updatecheck /></app>"))
       << post_interceptor_->GetRequestsAsString();
   EXPECT_NE(
       string::npos,
       post_interceptor_->GetRequests()[1].find(
           "<app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" "
           "version=\"0.9\" nextversion=\"1.0\">"
           "<event eventtype=\"3\" eventresult=\"1\"/>"))
       << post_interceptor_->GetRequestsAsString();
 
-  // Also check what happens if previous check too soon.
+  // Also check what happens if previous check too soon. It works, since this
+  // direct OnDemand call does not implement a cooldown.
   test_configurator()->SetOnDemandTime(60 * 60);
   EXPECT_EQ(
-      ComponentUpdateService::kError,
+      ComponentUpdateService::kOk,
       OnDemandTester::OnDemand(component_updater(), GetCrxComponentID(com2)));
   // Okay, now reset to 0 for the other tests.
   test_configurator()->SetOnDemandTime(0);
   component_updater()->Stop();
 
   // Test a few error cases. NOTE: We don't have callbacks for
   // when the updates failed yet.
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
   {
     InSequence seq;
@@ skipping 694 matching lines @@
     CHECK(defer);
   }
 
  private:
   void ResumeCalled() { ++resume_called_; }
 
   content::ResourceThrottle* throttle_;
   int resume_called_;
 };
 
+// Tests the on-demand update with resource throttle, including the
+// cooldown interval between calls.
 TEST_F(ComponentUpdaterTest, ResourceThrottleLiveNoUpdate) {
   MockServiceObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer,
                 OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
         .Times(1);
     EXPECT_CALL(observer,
                 OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
                         "abagagagagagagagagagagagagagagag"))
         .Times(1);
     EXPECT_CALL(observer,
                 OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
         .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+        .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+        .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+        .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+        .Times(1);
   }
 
   EXPECT_TRUE(post_interceptor_->ExpectRequest(
       new PartialMatch("updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   TestInstaller installer;
   CrxComponent com;
   component_updater()->AddObserver(&observer);
   EXPECT_EQ(
       ComponentUpdateService::kOk,
       RegisterComponent(&com, kTestComponent_abag, Version("1.1"), &installer));
   // The following two calls ensure that we don't do an update check via the
   // timer, so the only update check should be the on-demand one.
   test_configurator()->SetInitialDelay(1000000);
   test_configurator()->SetRecheckTime(1000000);
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
 
   RunThreadsUntilIdle();
 
   EXPECT_EQ(0, post_interceptor_->GetHitCount());
 
-  CancelResourceController controller;
+  {
+    // First on-demand update check is expected to succeeded.
+    CancelResourceController controller;
 
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&RequestTestResourceThrottle),
-                 component_updater(),
-                 &controller,
-                 "abagagagagagagagagagagagagagagag"));
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&RequestTestResourceThrottle),
+                   component_updater(),
+                   &controller,
+                   "abagagagagagagagagagagagagagagag"));
 
-  RunThreads();
+    RunThreads();
 
-  EXPECT_EQ(1, post_interceptor_->GetHitCount());
-  EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
-  EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
+    EXPECT_EQ(1, post_interceptor_->GetHitCount());
+    EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
+    EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
-  component_updater()->Stop();
+    component_updater()->Stop();
+  }
+
+  {
+    // Second on-demand update check is expected to succeed as well, since there
+    // is no cooldown interval between calls, due to calling SetOnDemandTime.
+    test_configurator()->SetOnDemandTime(0);
+    test_configurator()->SetLoopCount(1);
+    component_updater()->Start();
+
+    CancelResourceController controller;
+
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&RequestTestResourceThrottle),
+                   component_updater(),
+                   &controller,
+                   "abagagagagagagagagagagagagagagag"));
+
+    RunThreads();
+
+    EXPECT_EQ(1, post_interceptor_->GetHitCount());
+    EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
+    EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
+
+    component_updater()->Stop();
+  }
+
+  {
+    // This on-demand call is expected not to trigger a component update check.
+    test_configurator()->SetOnDemandTime(1000000);
+    component_updater()->Start();
+
+    CancelResourceController controller;
+
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&RequestTestResourceThrottle),
+                   component_updater(),
+                   &controller,
+                   "abagagagagagagagagagagagagagagag"));
+    RunThreadsUntilIdle();
+  }
 }
 
 // Tests adding and removing observers.
 TEST_F(ComponentUpdaterTest, Observer) {
   MockServiceObserver observer1, observer2;
 
   // Expect that two observers see the events.
   {
     InSequence seq;
     EXPECT_CALL(observer1,
@@ skipping 63 matching lines @@
   component_updater()->RemoveObserver(&observer2);
 
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   RunThreads();
 
   component_updater()->Stop();
 }
 
 }  // namespace component_updater