Add an API to component_updater that asks to do an update check "now".

chrome/browser/component_updater/test/component_updater_service_unittest.cc

 // Copyright (c) 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/component_updater_service.h"
 
+#include <list>
+#include <utility>
+
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_notification_tracker.h"
 #include "content/test/net/url_request_prepackaged_interceptor.h"
 #include "googleurl/src/gurl.h"
 #include "libxml/globals.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::TestNotificationTracker;
 
 namespace {
 // Overrides some of the component updater behaviors so it is easier to test
 // and loops faster. In actual usage it takes hours do to a full cycle.
 class TestConfigurator : public ComponentUpdateService::Configurator {
  public:
-  TestConfigurator() : times_(1), recheck_time_(0) {
+  TestConfigurator()
+      : times_(1), recheck_time_(0), ondemand_time_(0), cus_(NULL) {
   }
 
   virtual int InitialDelay() OVERRIDE { return 0; }
 
+  typedef std::pair<CrxComponent*, int> CheckAtLoopCount;
+
   virtual int NextCheckDelay() OVERRIDE {
     // This is called when a new full cycle of checking for updates is going
     // to happen. In test we normally only test one cycle so it is a good
     // time to break from the test messageloop Run() method so the test can
     // finish.
-    if (--times_ > 0)
-      return 1;
+    if (--times_ <= 0) {
+      MessageLoop::current()->Quit();
+      return 0;
 
-    MessageLoop::current()->Quit();
-    return 0;
+    }
+
+    // Look for checks to issue in the middle of the loop.
+    for (std::list<CheckAtLoopCount>::iterator
+             i = components_to_check_.begin();
+         i != components_to_check_.end(); ) {
+      if (i->second == times_) {
+        cus_->CheckForUpdateSoon(*i->first);
+        i = components_to_check_.erase(i);
+      } else {
+        ++i;
+      }
+    }
+    return 1;
   }
 
   virtual int StepDelay() OVERRIDE {
     return 0;
   }
 
   virtual int MinimumReCheckWait() OVERRIDE {
     return recheck_time_;
   }
 
+  virtual int OnDemandDelay() OVERRIDE {
+    return ondemand_time_;
+  }
+
   virtual GURL UpdateUrl(CrxComponent::UrlSource source) OVERRIDE {
     switch (source) {
       case CrxComponent::BANDAID:
         return GURL("http://localhost/upd");
       case CrxComponent::CWS_PUBLIC:
         return GURL("http://localhost/cws");
       default:
         return GURL("http://wronghost/bad");
     };
   }
@@ skipping 12 matching lines @@
 
   virtual void OnEvent(Events event, int extra) OVERRIDE { }
 
   // Set how many update checks are called, the default value is just once.
   void SetLoopCount(int times) { times_ = times; }
 
   void SetRecheckTime(int seconds) {
     recheck_time_ = seconds;
   }
 
+  void SetOnDemandTime(int seconds) {
+    ondemand_time_ = seconds;
+  }
+
+  void AddComponentToCheck(CrxComponent* com, int at_loop_iter) {
+    components_to_check_.push_back(std::make_pair(com, at_loop_iter));
+  }
+
+  void SetComponentUpdateService(ComponentUpdateService* cus) {
+    cus_ = cus;
+  }
+
  private:
   int times_;
   int recheck_time_;
+  int ondemand_time_;
+
+  std::list<CheckAtLoopCount> components_to_check_;
+  ComponentUpdateService* cus_;
 };
 
 class TestInstaller : public ComponentInstaller {
  public :
   explicit TestInstaller()
       : error_(0), install_count_(0) {
   }
 
   virtual void OnUpdateError(int error) OVERRIDE {
     EXPECT_NE(0, error);
@@ skipping 39 matching lines @@
  public:
   enum TestComponents {
     kTestComponent_abag,
     kTestComponent_jebg
   };
 
   ComponentUpdaterTest() : component_updater_(NULL), test_config_(NULL) {
     // The component updater instance under test.
     test_config_ = new TestConfigurator;
     component_updater_.reset(ComponentUpdateServiceFactory(test_config_));
+    test_config_->SetComponentUpdateService(component_updater_.get());
     // The test directory is chrome/test/data/components.
     PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_);
     test_data_dir_ = test_data_dir_.AppendASCII("components");
 
     // Subscribe to all component updater notifications.
     const int notifications[] = {
       chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED,
       chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING,
       chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND,
       chrome::NOTIFICATION_COMPONENT_UPDATE_READY
@@ skipping 209 matching lines @@
   TestNotificationTracker::Event ev1 = notification_tracker().at(1);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND, ev1.type);
 
   TestNotificationTracker::Event ev2 = notification_tracker().at(2);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_READY, ev2.type);
 
   TestNotificationTracker::Event ev3 = notification_tracker().at(3);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
 
   TestNotificationTracker::Event ev4 = notification_tracker().at(4);
-  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev4.type);
 
   component_updater()->Stop();
 }
 
 // This test is like the above InstallCrx but the second component
 // has a different source. In this case there would be two manifest
 // checks to different urls, each only containing one component.
 TEST_F(ComponentUpdaterTest, InstallCrxTwoSources) {
   MessageLoop message_loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
@@ skipping 51 matching lines @@
   TestNotificationTracker::Event ev1 = notification_tracker().at(2);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND, ev1.type);
 
   TestNotificationTracker::Event ev2 = notification_tracker().at(3);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_READY, ev2.type);
 
   TestNotificationTracker::Event ev3 = notification_tracker().at(4);
   EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
 
   TestNotificationTracker::Event ev4 = notification_tracker().at(5);
-  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev3.type);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev4.type);
 
   component_updater()->Stop();
 }
 
 // This test checks that the "prodversionmin" value is handled correctly. In
 // particular there should not be an install because the minimum product
 // version is much higher than of chrome.
 TEST_F(ComponentUpdaterTest, ProdVersionCheck) {
   MessageLoop message_loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
@@ skipping 20 matching lines @@
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   message_loop.Run();
 
   EXPECT_EQ(1, interceptor.GetHitCount());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
   component_updater()->Stop();
 }
+
+// Test that a ping for an update check can cause installs.
+// Here is the timeline:
+//  - First loop: we return a reply that indicates no update, so
+//    nothing happens.
+//  - We ping.
+//  - This triggers a second loop, which has a reply that triggers an install.
+TEST_F(ComponentUpdaterTest, CheckForUpdateSoon) {
+  MessageLoop message_loop;
+  content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
+  content::TestBrowserThread file_thread(BrowserThread::FILE);
+  content::TestBrowserThread io_thread(BrowserThread::IO);
+
+  io_thread.StartIOThread();
+  file_thread.Start();
+
+  content::URLRequestPrepackagedInterceptor interceptor;
+
+  CrxComponent com1;
+  RegisterComponent(&com1, kTestComponent_abag, Version("2.2"));
+  CrxComponent com2;
+  RegisterComponent(&com2, kTestComponent_jebg, Version("0.9"));
+
+  const GURL expected_update_url_1(
+      "http://localhost/upd?extra=foo&x=id%3D"
+      "abagagagagagagagagagagagagagagag%26v%3D2.2%26uc&x=id%3D"
+      "jebgalgnebhfojomionfpkfelancnnkf%26v%3D0.9%26uc");
+
+  const GURL expected_update_url_2(
+      "http://localhost/upd?extra=foo&x=id%3D"
+      "jebgalgnebhfojomionfpkfelancnnkf%26v%3D0.9%26uc&x=id%3D"
+      "abagagagagagagagagagagagagagagag%26v%3D2.2%26uc");
+
+  interceptor.SetResponse(expected_update_url_1,
+                          test_file("updatecheck_reply_empty"));
+  interceptor.SetResponse(expected_update_url_2,
+                          test_file("updatecheck_reply_1.xml"));
+  interceptor.SetResponse(GURL(expected_crx_url),
+                          test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
+  // Test success.
+  test_configurator()->SetLoopCount(2);
+  test_configurator()->AddComponentToCheck(&com2, 1);
+  component_updater()->Start();
+  message_loop.Run();
+
+  EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->error());
+  EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->install_count());
+  EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->error());
+  EXPECT_EQ(1, static_cast<TestInstaller*>(com2.installer)->install_count());
+
+  EXPECT_EQ(3, interceptor.GetHitCount());
+
+  ASSERT_EQ(5ul, notification_tracker().size());
+
+  TestNotificationTracker::Event ev0= notification_tracker().at(0);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED, ev0.type);
+
+  TestNotificationTracker::Event ev1 = notification_tracker().at(1);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev1.type);
+
+  TestNotificationTracker::Event ev2 = notification_tracker().at(2);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND, ev2.type);
+
+  TestNotificationTracker::Event ev3 = notification_tracker().at(3);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATE_READY, ev3.type);
+
+  TestNotificationTracker::Event ev4 = notification_tracker().at(4);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev4.type);
+
+  // Also check what happens if previous check too soon.
+  test_configurator()->SetOnDemandTime(60 * 60);
+  EXPECT_EQ(ComponentUpdateService::kError,
+            component_updater()->CheckForUpdateSoon(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.
+  const GURL expected_update_url_3(
+      "http://localhost/upd?extra=foo&x=id%3D"
+      "jebgalgnebhfojomionfpkfelancnnkf%26v%3D1.0%26uc&x=id%3D"
+      "abagagagagagagagagagagagagagagag%26v%3D2.2%26uc");
+
+  // No update: error from no server response
+  interceptor.SetResponse(expected_update_url_3,
+                          test_file("updatecheck_reply_empty"));
+  notification_tracker().Reset();
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  EXPECT_EQ(ComponentUpdateService::kOk,
+            component_updater()->CheckForUpdateSoon(com2));
+
+  message_loop.Run();
+
+  ASSERT_EQ(2ul, notification_tracker().size());
+  ev0 = notification_tracker().at(0);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED, ev0.type);
+  ev1 = notification_tracker().at(1);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev1.type);
+  component_updater()->Stop();
+
+  // No update: already updated to 1.0 so nothing new
+  interceptor.SetResponse(expected_update_url_3,
+                          test_file("updatecheck_reply_1.xml"));
+  notification_tracker().Reset();
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  EXPECT_EQ(ComponentUpdateService::kOk,
+            component_updater()->CheckForUpdateSoon(com2));
+
+  message_loop.Run();
+
+  ASSERT_EQ(2ul, notification_tracker().size());
+  ev0 = notification_tracker().at(0);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED, ev0.type);
+  ev1 = notification_tracker().at(1);
+  EXPECT_EQ(chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING, ev1.type);
+  component_updater()->Stop();
+}