Implemented completion pings for component updates.

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 <list>
 #include <utility>
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 65 matching lines @@
 
 int TestConfigurator::MinimumReCheckWait() {
   return recheck_time_;
 }
 
 int TestConfigurator::OnDemandDelay() {
   return ondemand_time_;
 }
 
 GURL TestConfigurator::UpdateUrl() {
-  return GURL("http://localhost/upd");
+      return GURL("http://localhost/upd");
+}
+
+GURL TestConfigurator::PingUrl() {
+  return GURL("http://localhost2/ping");
 }
 
 const char* TestConfigurator::ExtraRequestParams() { return "extra=foo"; }
 
 size_t TestConfigurator::UrlSizeLimit() { return 256; }
 
 net::URLRequestContextGetter* TestConfigurator::RequestContext() {
   return new net::TestURLRequestContextGetter(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 }
 
 // Don't use the utility process to decode files.
 bool TestConfigurator::InProcess() { return true; }
 
-void TestConfigurator::OnEvent(Events event, int extra) { }
-
 ComponentPatcher* TestConfigurator::CreateComponentPatcher() {
   return new MockComponentPatcher();
 }
 
 bool TestConfigurator::DeltasEnabled() const {
   return true;
 }
 
 // Set how many update checks are called, the default value is just once.
 void TestConfigurator::SetLoopCount(int times) { times_ = times; }
@@ skipping 77 matching lines @@
     com->pk_hash.assign(jebg_hash, jebg_hash + arraysize(jebg_hash));
   } else {
     com->name = "test_ihfo";
     com->pk_hash.assign(ihfo_hash, ihfo_hash + arraysize(ihfo_hash));
   }
   com->version = version;
   com->installer = installer;
   return component_updater_->RegisterComponent(*com);
 }
 
+PingChecker::PingChecker(const std::map<std::string, std::string>& attributes)
+    : num_hits_(0), num_misses_(0), attributes_(attributes) {
+}
+
+PingChecker::~PingChecker() {}
+
+void PingChecker::Trial(net::URLRequest* request) {
+  if (Test(request))
+    ++num_hits_;
+  else
+    ++num_misses_;
+}
+
+bool PingChecker::Test(net::URLRequest* request) {
+  if (request->has_upload()) {
+    const net::UploadDataStream* stream = request->get_upload();
+    const net::UploadBytesElementReader* reader =
+        stream->element_readers()[0]->AsBytesReader();
+    int size = reader->length();
+    scoped_refptr <net::IOBuffer> buffer = new net::IOBuffer(size);
+    std::string data(reader->bytes());
+    // For now, we assume that there is only one ping per POST.
+    std::string::size_type start = data.find("<o:event");
+    if (start != std::string::npos) {
+      std::string::size_type end = data.find(">", start);
+      if (end != std::string::npos) {
+        std::string ping = data.substr(start, end - start);
+        std::map<std::string, std::string>::const_iterator iter;
+        for (iter = attributes_.begin(); iter != attributes_.end(); ++iter) {
+          // does the ping contain the specified attribute/value?
+          if (ping.find(std::string(" ") + (iter->first) +
+              std::string("=") + (iter->second)) == string::npos) {
+            return false;
+          }
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 // Verify that our test fixture work and the component updater can
 // be created and destroyed with no side effects.
 TEST_F(ComponentUpdaterTest, VerifyFixture) {
   EXPECT_TRUE(component_updater() != NULL);
   EXPECT_EQ(0ul, notification_tracker().size());
 }
 
 // Verify that the component updater can be caught in a quick
 // start-shutdown situation. Failure of this test will be a crash. Also
 // if there is no work to do, there are no notifications generated.
@@ skipping 83 matching lines @@
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
   component_updater()->Stop();
 }
 
 // Verify that we can check for updates and install one component. Besides
 // the notifications above NOTIFICATION_COMPONENT_UPDATE_FOUND and
 // NOTIFICATION_COMPONENT_UPDATE_READY should have been fired. We do two loops
 // so the second time around there should be nothing left to do.
-// We also check that only 3 network requests are issued:
+// We also check that only 3 non-ping network requests are issued:
 // 1- manifest check
 // 2- download crx
 // 3- second manifest check.
 TEST_F(ComponentUpdaterTest, InstallCrx) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"1\""));
+  map.insert(std::pair<std::string, std::string>("previousversion",
+                                                 "\"0.9\""));
+  map.insert(std::pair<std::string, std::string>("nextversion", "\"1.0\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   TestInstaller installer1;
   CrxComponent com1;
   RegisterComponent(&com1, kTestComponent_jebg, Version("0.9"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
   RegisterComponent(&com2, kTestComponent_abag, Version("2.2"), &installer2);
 
   const GURL expected_update_url_1(
@@ skipping 17 matching lines @@
 
   component_updater()->Start();
   message_loop.Run();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->error());
   EXPECT_EQ(1, static_cast<TestInstaller*>(com1.installer)->install_count());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->install_count());
 
   EXPECT_EQ(3, interceptor.GetHitCount());
+  EXPECT_EQ(1, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
 
   ASSERT_EQ(5ul, notification_tracker().size());
 
   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);
@@ skipping 10 matching lines @@
 // version is much higher than of chrome.
 TEST_F(ComponentUpdaterTest, ProdVersionCheck) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   TestInstaller installer;
   CrxComponent com;
   RegisterComponent(&com, kTestComponent_jebg, Version("0.9"), &installer);
 
   const GURL expected_update_url(
       "http://localhost/upd?extra=foo&x=id%3D"
       "jebgalgnebhfojomionfpkfelancnnkf%26v%3D0.9%26fp%3D%26uc");
 
   interceptor.SetResponse(expected_update_url,
                           test_file("updatecheck_reply_2.xml"));
   interceptor.SetResponse(GURL(expected_crx_url),
                           test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
 
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   message_loop.Run();
 
+  EXPECT_EQ(0, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
   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) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"1\""));
+  map.insert(std::pair<std::string, std::string>("previousversion",
+                                                 "\"0.9\""));
+  map.insert(std::pair<std::string, std::string>("nextversion", "\"1.0\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   TestInstaller installer1;
   CrxComponent com1;
   RegisterComponent(&com1, kTestComponent_abag, Version("2.2"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
   RegisterComponent(&com2, kTestComponent_jebg, Version("0.9"), &installer2);
 
   const GURL expected_update_url_1(
@@ skipping 80 matching lines @@
   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();
 
+  EXPECT_EQ(1, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
   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();
 }
 
 // Verify that a previously registered component can get re-registered
 // with a different version.
 TEST_F(ComponentUpdaterTest, CheckReRegistration) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"1\""));
+  map.insert(std::pair<std::string, std::string>("previousversion",
+                                                 "\"0.9\""));
+  map.insert(std::pair<std::string, std::string>("nextversion", "\"1.0\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   TestInstaller installer1;
   CrxComponent com1;
   RegisterComponent(&com1, kTestComponent_jebg, Version("0.9"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
   RegisterComponent(&com2, kTestComponent_abag, Version("2.2"), &installer2);
 
   // Start with 0.9, and update to 1.0
@@ skipping 19 matching lines @@
   test_configurator()->SetLoopCount(2);
 
   component_updater()->Start();
   message_loop.Run();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->error());
   EXPECT_EQ(1, static_cast<TestInstaller*>(com1.installer)->install_count());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->install_count());
 
+  EXPECT_EQ(1, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
   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_UPDATE_FOUND, ev1.type);
 
@@ skipping 48 matching lines @@
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->install_count());
 
   component_updater()->Stop();
 }
 
 // Verify that component installation falls back to downloading and installing
 // a full update if the differential update fails (in this case, because the
 // installer does not know about the existing files). We do two loops; the final
 // loop should do nothing.
-// We also check that exactly 4 network requests are issued:
+// We also check that exactly 4 non-ping network requests are issued:
 // 1- update check (loop 1)
 // 2- download differential crx
 // 3- download full crx
 // 4- update check (loop 2 - no update available)
+// There should be one ping for the first attempted update.
 TEST_F(ComponentUpdaterTest, DifferentialUpdateFails) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"1\""));
+  map.insert(std::pair<std::string, std::string>("diffresult", "\"0\""));
+  map.insert(std::pair<std::string, std::string>("differrorcode", "\"16\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   TestInstaller installer;
   CrxComponent com;
   RegisterComponent(&com, kTestComponent_ihfo, Version("1.0"), &installer);
 
   const GURL expected_update_url_1(
       "http://localhost/upd?extra=foo"
       "&x=id%3Dihfokbkgjpifnbbojhneepfflplebdkc%26v%3D1.0%26fp%3D%26uc");
   const GURL expected_update_url_2(
@@ skipping 20 matching lines @@
 
   test_configurator()->SetLoopCount(2);
 
   component_updater()->Start();
   message_loop.Run();
 
   // A failed differential update does not count as a failed install.
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(1, static_cast<TestInstaller*>(com.installer)->install_count());
 
+  EXPECT_EQ(1, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
   EXPECT_EQ(4, interceptor.GetHitCount());
 
   component_updater()->Stop();
 }
 
+// Verify that a failed installation causes an install failure ping.
+TEST_F(ComponentUpdaterTest, CheckFailedInstallPing) {
+  base::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();
+
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"0\""));
+  map.insert(std::pair<std::string, std::string>("errorcode", "\"9\""));
+  map.insert(std::pair<std::string, std::string>("previousversion",
+                                                 "\"0.9\""));
+  map.insert(std::pair<std::string, std::string>("nextversion", "\"1.0\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
+  content::URLLocalHostRequestPrepackagedInterceptor interceptor;
+
+  // This test installer reports installation failure.
+  class : public TestInstaller {
+    virtual bool Install(const base::DictionaryValue& manifest,
+                         const base::FilePath& unpack_path) OVERRIDE {
+      ++install_count_;
+      base::Delete(unpack_path, true);
+      return false;
+    }
+  } installer;
+
+  CrxComponent com;
+  RegisterComponent(&com, kTestComponent_jebg, Version("0.9"), &installer);
+
+  // Start with 0.9, and attempt update to 1.0
+  const GURL expected_update_url_1(
+      "http://localhost/upd?extra=foo"
+      "&x=id%3Djebgalgnebhfojomionfpkfelancnnkf%26v%3D0.9%26fp%3D%26uc");
+
+  interceptor.SetResponse(expected_update_url_1,
+                          test_file("updatecheck_reply_1.xml"));
+  interceptor.SetResponse(GURL(expected_crx_url),
+                          test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
+
+  // Loop twice to issue two checks: (1) with original 0.9 version
+  // and (2), which should retry with 0.9.
+  test_configurator()->SetLoopCount(2);
+  component_updater()->Start();
+  message_loop.Run();
+
+  // Loop once more, but expect no ping because a noupdate response is issued.
+  // This is necessary to clear out the fire-and-forget ping from the previous
+  // iteration.
+  interceptor.SetResponse(expected_update_url_1,
+                          test_file("updatecheck_reply_noupdate.xml"));
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  message_loop.Run();
+
+  EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
+  EXPECT_EQ(2, static_cast<TestInstaller*>(com.installer)->install_count());
+
+  EXPECT_EQ(2, ping_checker.NumHits());
+  EXPECT_EQ(0, ping_checker.NumMisses());
+  EXPECT_EQ(5, interceptor.GetHitCount());
+
+  component_updater()->Stop();
+}
+
 // Verify that we successfully propagate a patcher error.
 // ihfokbkgjpifnbbojhneepfflplebdkc_1to2_bad.crx contains an incorrect
 // patching instruction that should fail.
 TEST_F(ComponentUpdaterTest, DifferentialUpdateFailErrorcode) {
   base::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();
 
+  std::map<std::string, std::string> map;
+  map.insert(std::pair<std::string, std::string>("eventtype", "\"3\""));
+  map.insert(std::pair<std::string, std::string>("eventresult", "\"1\""));
+  map.insert(std::pair<std::string, std::string>("diffresult", "\"0\""));
+  map.insert(std::pair<std::string, std::string>("differrorcode", "\"14\""));
+  map.insert(std::pair<std::string, std::string>("diffextracode1", "\"305\""));
+  PingChecker ping_checker(map);
+  URLRequestPostInterceptor post_interceptor(&ping_checker);
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   VersionedTestInstaller installer;
   CrxComponent com;
   RegisterComponent(&com, kTestComponent_ihfo, Version("0.0"), &installer);
 
   const GURL expected_update_url_0(
       "http://localhost/upd?extra=foo"
       "&x=id%3Dihfokbkgjpifnbbojhneepfflplebdkc%26v%3D0.0%26fp%3D%26uc");
   const GURL expected_update_url_1(
@@ skipping 24 matching lines @@
                           test_file("ihfokbkgjpifnbbojhneepfflplebdkc_2.crx"));
 
   test_configurator()->SetLoopCount(3);
 
   component_updater()->Start();
   message_loop.Run();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(2, static_cast<TestInstaller*>(com.installer)->install_count());
 
+  EXPECT_EQ(1, ping_checker.NumHits());
+  EXPECT_EQ(1, ping_checker.NumMisses());
   EXPECT_EQ(6, interceptor.GetHitCount());
 
   component_updater()->Stop();
 }