First changelist of a series to migrate the component updater protocol

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/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/stringprintf.h"
@@ skipping 100 matching lines @@
 }
 
 void TestConfigurator::SetComponentUpdateService(ComponentUpdateService* cus) {
   cus_ = cus;
 }
 
 void TestConfigurator::SetQuitClosure(const base::Closure& quit_closure) {
   quit_closure_ = quit_closure;
 }
 
+// Intercepts ping requests sent over http POST to localhost2.
+class PingInterceptor : public URLRequestPostInterceptor {
+ public:
+  PingInterceptor() : URLRequestPostInterceptor("http", "localhost2") {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PingInterceptor);
+};
+
 ComponentUpdaterTest::ComponentUpdaterTest()
     : test_config_(NULL),
       thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
   // 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_);
@@ skipping 46 matching lines @@
 void ComponentUpdaterTest::RunThreads() {
   base::RunLoop runloop;
   test_configurator()->SetQuitClosure(runloop.QuitClosure());
   runloop.Run();
 }
 
 void ComponentUpdaterTest::RunThreadsUntilIdle() {
   base::RunLoop().RunUntilIdle();
 }
 
-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());
-    pings_.push_back(data);
-    // 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;
-}
-
-std::string PingChecker::GetPings() const {
-  std::string pings_str = "Pings are:";
-  int i = 0;
-  for (std::vector<std::string>::const_iterator it = pings_.begin();
-      it != pings_.end(); ++it) {
-    pings_str.append(base::StringPrintf("\n  (%d): %s", ++i, it->c_str()));
-  }
-  return pings_str;
-}
-
 ComponentUpdateService::Status OnDemandTester::OnDemand(
     ComponentUpdateService* cus, const std::string& component_id) {
   return cus->OnDemandUpdate(component_id);
 }
 
 // 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);
 }
 
 // Verify that the component updater can be caught in a quick
 // start-shutdown situation. Failure of this test will be a crash.
 TEST_F(ComponentUpdaterTest, StartStop) {
   component_updater()->Start();
   RunThreadsUntilIdle();
   component_updater()->Stop();
 }
 
 // Verify that when the server has no updates, we go back to sleep and
 // the COMPONENT_UPDATER_STARTED and COMPONENT_UPDATER_SLEEPING notifications
-// are generated.
+// are generated. No pings are sent.
 TEST_F(ComponentUpdaterTest, CheckCrxSleep) {
+  PingInterceptor ping_interceptor;
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   MockComponentObserver observer;
 
   TestInstaller installer;
   CrxComponent com;
   com.observer = &observer;
   EXPECT_EQ(ComponentUpdateService::kOk,
             RegisterComponent(&com,
                               kTestComponent_abag,
@@ skipping 46 matching lines @@
 
   EXPECT_CALL(observer,
               OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
               .Times(2);
   EXPECT_CALL(observer,
               OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
               .Times(2);
   RunThreads();
 
   EXPECT_EQ(4, interceptor.GetHitCount());
+  EXPECT_EQ(0, ping_interceptor.GetHitCount());
 
   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 COMPONENT_UPDATE_FOUND and 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 non-ping network requests are issued:
 // 1- manifest check
 // 2- download crx
 // 3- second manifest check.
 TEST_F(ComponentUpdaterTest, InstallCrx) {
-  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);
+  PingInterceptor ping_interceptor;
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   MockComponentObserver observer1;
   {
     InSequence seq;
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
                 .Times(1);
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATE_FOUND, 0))
@@ skipping 65 matching lines @@
 
   component_updater()->Start();
   RunThreads();
 
   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()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+
+  EXPECT_EQ(1, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+    "<o:app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"1.0\">"
+    "<o:event eventtype=\"3\" eventresult=\"1\" "
+    "previousversion=\"0.9\" nextversion=\"1.0\"/></o:app>"));

[waffles, 2013/11/04 18:32:45]

I notice you're not printing the pings if we fail to find a match - I think it's
more likely that someone will break the tests by changing the ping text than by
changing the ping count; do we want to print the pings for the EXPECT_NE as
well?

Doesn't seem like a big deal (unless the tests get flaky again).

 
   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) {
-  std::map<std::string, std::string> map;
-  PingChecker ping_checker(map);
-  URLRequestPostInterceptor post_interceptor(&ping_checker);
+  PingInterceptor ping_interceptor;
   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();
   RunThreads();
 
-  EXPECT_EQ(0, ping_checker.NumHits()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(0, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
   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, OnDemandUpdate) {
-  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);
+  PingInterceptor ping_interceptor;
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   MockComponentObserver observer1;
   {
     InSequence seq;
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
                 .Times(1);
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
@@ skipping 175 matching lines @@
   interceptor.SetResponse(expected_update_url_3,
                           test_file("updatecheck_reply_1.xml"));
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   EXPECT_EQ(ComponentUpdateService::kOk,
             OnDemandTester::OnDemand(component_updater(),
                                      GetCrxComponentID(com2)));
 
   RunThreads();
 
-  EXPECT_EQ(1, ping_checker.NumHits()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(1, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+    "<o:app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"1.0\">"
+    "<o:event eventtype=\"3\" eventresult=\"1\" "
+    "previousversion=\"0.9\" nextversion=\"1.0\"/></o:app>"));
 
   component_updater()->Stop();
 }
 
 // Verify that a previously registered component can get re-registered
 // with a different version.
 TEST_F(ComponentUpdaterTest, CheckReRegistration) {
-  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);
+  PingInterceptor ping_interceptor;
   content::URLLocalHostRequestPrepackagedInterceptor interceptor;
 
   MockComponentObserver observer1;
   {
     InSequence seq;
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
                 .Times(1);
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATE_FOUND, 0))
@@ skipping 67 matching lines @@
   test_configurator()->SetLoopCount(2);
 
   component_updater()->Start();
   RunThreads();
 
   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()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(1, ping_interceptor.GetHitCount())
+        << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+    "<o:app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"1.0\">"
+    "<o:event eventtype=\"3\" eventresult=\"1\" "
+    "previousversion=\"0.9\" nextversion=\"1.0\"/></o:app>"));
+
   EXPECT_EQ(3, interceptor.GetHitCount());
 
   component_updater()->Stop();
 
   // Now re-register, pretending to be an even newer version (2.2)
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
   {
     InSequence seq;
     EXPECT_CALL(observer1,
                 OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
@@ skipping 58 matching lines @@
 // nothing.
 // We also check that exactly 5 non-ping network requests are issued:
 // 1- update check (response: v1 available)
 // 2- download crx (v1)
 // 3- update check (response: v2 available)
 // 4- download differential crx (v1 to v2)
 // 5- update check (response: no further update available)
 // There should be two pings, one for each update. The second will bear a
 // diffresult=1, while the first will not.
 TEST_F(ComponentUpdaterTest, DifferentialUpdate) {
-  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", "\"1\""));
-  PingChecker ping_checker(map);
-  URLRequestPostInterceptor post_interceptor(&ping_checker);
+  PingInterceptor ping_interceptor;
   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 21 matching lines @@
 
   test_configurator()->SetLoopCount(3);
 
   component_updater()->Start();
   RunThreads();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(2, static_cast<TestInstaller*>(com.installer)->install_count());
 
   // One ping has the diffresult=1, the other does not.
-  EXPECT_EQ(1, ping_checker.NumHits()) << ping_checker.GetPings();
-  EXPECT_EQ(1, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(2, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+      "<o:app appid=\"ihfokbkgjpifnbbojhneepfflplebdkc\" version=\"1.0\">"
+      "<o:event eventtype=\"3\" eventresult=\"1\" "
+      "previousversion=\"0.0\" nextversion=\"1.0\" nextfp=\"1\"/></o:app>"));
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[1].find(
+      "<o:app appid=\"ihfokbkgjpifnbbojhneepfflplebdkc\" version=\"2.0\">"
+      "<o:event eventtype=\"3\" eventresult=\"1\" "
+      "previousversion=\"1.0\" nextversion=\"2.0\" "
+      "diffresult=\"1\" previousfp=\"1\" nextfp=\"f22\"/></o:app>"));
 
   EXPECT_EQ(5, interceptor.GetHitCount());
 
   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 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) {
-  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);
+  PingInterceptor ping_interceptor;
   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();
   RunThreads();
 
   // 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()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(1, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+      "<o:app appid=\"ihfokbkgjpifnbbojhneepfflplebdkc\" version=\"2.0\">"
+      "<o:event eventtype=\"3\" eventresult=\"1\" "
+      "previousversion=\"1.0\" nextversion=\"2.0\" "
+      "diffresult=\"0\" differrorcat=\"2\" differrorcode=\"16\" "
+      "nextfp=\"f22\"/></o:app>"));
+
   EXPECT_EQ(4, interceptor.GetHitCount());
 
   component_updater()->Stop();
 }
 
 // Verify that a failed installation causes an install failure ping.
 TEST_F(ComponentUpdaterTest, CheckFailedInstallPing) {
-  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);
+  PingInterceptor ping_interceptor;
   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::DeleteFile(unpack_path, true);
       return false;
     }
@@ skipping 23 matching lines @@
   // iteration.
   interceptor.SetResponse(expected_update_url_1,
                           test_file("updatecheck_reply_noupdate.xml"));
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   RunThreads();
 
   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()) << ping_checker.GetPings();
-  EXPECT_EQ(0, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(2, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+      "<o:app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"0.9\">"
+      "<o:event eventtype=\"3\" eventresult=\"0\" "
+      "previousversion=\"0.9\" nextversion=\"1.0\" "
+      "errorcat=\"3\" errorcode=\"9\"/></o:app>"));
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[1].find(
+      "<o:app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"0.9\">"
+      "<o:event eventtype=\"3\" eventresult=\"0\" "
+      "previousversion=\"0.9\" nextversion=\"1.0\" "
+      "errorcat=\"3\" errorcode=\"9\"/></o:app>"));
+
   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) {
-  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);
+  PingInterceptor ping_interceptor;
   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 27 matching lines @@
 
   component_updater()->Start();
   RunThreads();
   component_updater()->Stop();
   // There may still be pings in the queue.
   RunThreadsUntilIdle();
 
   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()) << ping_checker.GetPings();
-  EXPECT_EQ(1, ping_checker.NumMisses()) << ping_checker.GetPings();
+  EXPECT_EQ(2, ping_interceptor.GetHitCount())
+      << ping_interceptor.GetRequestsAsString();
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[0].find(
+      "<o:app appid=\"ihfokbkgjpifnbbojhneepfflplebdkc\" version=\"1.0\">"
+      "<o:event eventtype=\"3\" eventresult=\"1\" "
+      "previousversion=\"0.0\" nextversion=\"1.0\" nextfp=\"1\"/></o:app>"));
+  EXPECT_NE(string::npos, ping_interceptor.GetRequests()[1].find(
+      "<o:app appid=\"ihfokbkgjpifnbbojhneepfflplebdkc\" version=\"2.0\">"
+      "<o:event eventtype=\"3\" eventresult=\"1\" "
+      "previousversion=\"1.0\" nextversion=\"2.0\" "
+      "diffresult=\"0\" differrorcat=\"2\" "
+      "differrorcode=\"14\" diffextracode1=\"305\" "
+      "previousfp=\"1\" nextfp=\"f22\"/></o:app>"));
+
   EXPECT_EQ(5, interceptor.GetHitCount());
 }