[ios] Adds code for Omaha and the upgrade center.

ios/chrome/browser/omaha/omaha_service_unittest.mm

Index: ios/chrome/browser/omaha/omaha_service_unittest.mm
diff --git a/ios/chrome/browser/omaha/omaha_service_unittest.mm b/ios/chrome/browser/omaha/omaha_service_unittest.mm
new file mode 100644
index 0000000000000000000000000000000000000000..c1f590480bf7ace9a5def93eed7cf1686a00a3dc
--- /dev/null
+++ b/ios/chrome/browser/omaha/omaha_service_unittest.mm
@@ -0,0 +1,506 @@
+// 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.
+
+#import "ios/chrome/browser/omaha/omaha_service.h"
+
+#include <regex.h>
+#include <sys/types.h>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "components/metrics/metrics_pref_names.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/version_info/version_info.h"
+#include "ios/chrome/browser/application_context.h"
+#include "ios/chrome/browser/browser_state/test_chrome_browser_state_manager.h"
+#include "ios/chrome/browser/install_time_util.h"
+#include "ios/chrome/common/channel_info.h"
+#include "ios/chrome/test/testing_application_context.h"
+#include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
+#include "ios/public/provider/chrome/browser/omaha/omaha_service_provider.h"
+#include "ios/web/public/test/test_web_thread.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gtest_mac.h"
+#include "testing/platform_test.h"
+
+namespace {
+
+const char kUserDataDir[] = ".";
+
+}  // namespace
+
+class OmahaServiceTest : public PlatformTest {
+ public:
+  OmahaServiceTest()
+      : need_update_(false),
+        loop_(base::MessageLoop::TYPE_IO),
+        browser_state_manager_(base::FilePath(kUserDataDir)),
+        ui_thread_(web::WebThread::UI, &loop_),
+        io_thread_(web::WebThread::IO, &loop_) {
+    GetApplicationContext()->GetLocalState()->SetInt64(
+        metrics::prefs::kInstallDate, install_time_util::kUnknownInstallDate);
+    OmahaService::ClearPersistentStateForTests();
+    test_application_id_ = ios::GetChromeBrowserProvider()
+                               ->GetOmahaServiceProvider()
+                               ->GetApplicationID();
+  }
+
+  ~OmahaServiceTest() override {}
+
+  void OnNeedUpdate(const UpgradeRecommendedDetails& details) {
+    need_update_ = true;
+  }
+
+  bool NeedUpdate() {
+    DCHECK_CURRENTLY_ON(web::WebThread::UI);
+    if (!need_update_) {
+      base::RunLoop().RunUntilIdle();
+    }
+    return need_update_;
+  }
+
+  void CleanService(OmahaService* service,
+                    const std::string& last_sent_version) {
+    service->ClearInstallRetryRequestId();
+    service->number_of_tries_ = 0;
+    if (last_sent_version.length() == 0)
+      service->last_sent_version_ = base::Version("0.0.0.0");
+    else
+      service->last_sent_version_ = base::Version(last_sent_version);
+    service->current_ping_time_ = base::Time();
+    service->last_sent_time_ = base::Time();
+    service->locale_lang_ = std::string();
+  }
+
+ protected:
+  std::string test_application_id_;
+  bool need_update_;
+  base::MessageLoop loop_;
+  TestChromeBrowserStateManager browser_state_manager_;
+
+ private:
+  web::TestWebThread ui_thread_;
+  web::TestWebThread io_thread_;
+};
+
+TEST_F(OmahaServiceTest, PingMessageTest) {
+  const char* expectedResult =
+      "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" "
+      "requestid=\"requestId\" sessionid=\"sessionId\""
+      " hardware_class=\"[^\"]*\">"
+      "<os platform=\"ios\" version=\"[0-9][0-9]*\\(\\.[0-9][0-9]*\\)*\""
+      " arch=\"[^\"]*\"/>"
+      "<app version=\"[^\"]*\" nextversion=\"\" lang=\"[^\"]*\""
+      " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\""
+      " installage=\"0\">"
+      "<updatecheck tag=\"[^\"]*\"/>"
+      "<ping active=\"1\"/></app></request>";
+
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  std::string content = service.GetPingContent(
+      "requestId", "sessionId", version_info::GetVersionNumber(),
+      GetChannelString(), base::Time::Now(), OmahaService::USAGE_PING);
+  regex_t regex;
+  regcomp(&regex, expectedResult, REG_NOSUB);
+  int result = regexec(&regex, content.c_str(), 0, NULL, 0);
+  regfree(&regex);
+  EXPECT_EQ(0, result);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, PingMessageTestWithUnknownInstallDate) {
+  const char* expectedResult =
+      "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" "
+      "requestid=\"requestId\" sessionid=\"sessionId\""
+      " hardware_class=\"[^\"]*\">"
+      "<os platform=\"ios\" version=\"[0-9][0-9]*\\(\\.[0-9][0-9]*\\)*\""
+      " arch=\"[^\"]*\"/>"
+      "<app version=\"[^\"]*\" nextversion=\"\" lang=\"[^\"]*\""
+      " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\">"
+      "<updatecheck tag=\"[^\"]*\"/>"
+      "<ping active=\"1\"/></app></request>";
+
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  std::string content = service.GetPingContent(
+      "requestId", "sessionId", version_info::GetVersionNumber(),
+      GetChannelString(),
+      base::Time::FromTimeT(install_time_util::kUnknownInstallDate),
+      OmahaService::USAGE_PING);
+  regex_t regex;
+  regcomp(&regex, expectedResult, REG_NOSUB);
+  int result = regexec(&regex, content.c_str(), 0, NULL, 0);
+  regfree(&regex);
+  EXPECT_EQ(0, result);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, InstallEventMessageTest) {
+  const char* kExpectedResultFormat =
+      "<request protocol=\"3.0\" version=\"iOS-1.0.0.0\" ismachine=\"1\" "
+      "requestid=\"requestId\" sessionid=\"sessionId\""
+      " hardware_class=\"[^\"]*\">"
+      "<os platform=\"ios\" version=\"[0-9][0-9]*(\\.[0-9][0-9]*)*\""
+      " arch=\"[^\"]*\"/>"
+      "<app version=\"%s\" nextversion=\"[^\"]*\" lang=\"[^\"]*\""
+      " brand=\"[A-Z][A-Z][A-Z][A-Z]\" client=\"\" appid=\"{[^}]*}\""
+      " installage=\"%d\">"
+      "<event eventtype=\"%d\" eventresult=\"1\"/>"
+      "</app></request>";
+
+  // First install.
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, "");
+  std::string content = service.GetPingContent(
+      "requestId", "sessionId", version_info::GetVersionNumber(),
+      GetChannelString(), base::Time::Now(), OmahaService::INSTALL_EVENT);
+  regmatch_t matches[2];
+  regex_t regex;
+  std::string expected_result =
+      base::StringPrintf(kExpectedResultFormat, "" /* previous version */,
+                         -1 /* install age */, 2 /* event type */);
+  regcomp(&regex, expected_result.c_str(), REG_EXTENDED);
+  int result = regexec(&regex, content.c_str(), arraysize(matches), matches, 0);
+  regfree(&regex);
+  EXPECT_EQ(0, result) << "Actual contents: " << content;
+  EXPECT_FALSE(NeedUpdate());
+
+  // Update install.
+  const char* kPreviousVersion = "0.5";
+  CleanService(&service, kPreviousVersion);
+  content = service.GetPingContent(
+      "requestId", "sessionId", version_info::GetVersionNumber(),
+      GetChannelString(), base::Time::Now(), OmahaService::INSTALL_EVENT);
+  expected_result = base::StringPrintf(kExpectedResultFormat, kPreviousVersion,
+                                       0 /* install age */, 3 /* event type */);
+  regcomp(&regex, expected_result.c_str(), REG_EXTENDED);
+  result = regexec(&regex, content.c_str(), arraysize(matches), matches, 0);
+  regfree(&regex);
+  EXPECT_EQ(0, result) << "Actual contents: " << content;
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, SendPingSuccess) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, version_info::GetVersionNumber());
+  net::TestURLFetcherFactory factory_;
+
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"56754\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(0, service.number_of_tries_);
+  EXPECT_FALSE(service.current_ping_time_.is_null());
+  EXPECT_EQ(service.current_ping_time_, service.next_tries_time_);
+  EXPECT_GT(service.last_sent_time_, now);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, SendInstallEventSuccess) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, "");
+  net::TestURLFetcherFactory factory_;
+
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"56754\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<event status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_FALSE(service.current_ping_time_.is_null());
+  EXPECT_GT(service.last_sent_time_, now);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, SendPingReceiveUpdate) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, version_info::GetVersionNumber());
+  net::TestURLFetcherFactory factory_;
+
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"56754\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<updatecheck status=\"ok\"><urls>"
+      "<url codebase=\"http://www.goo.fr/foo/\"/></urls>"
+      "<manifest version=\"0.0.1075.1441\">"
+      "<packages>"
+      "<package hash=\"0\" name=\"Chrome\" required=\"true\" size=\"0\"/>"
+      "</packages>"
+      "<actions>"
+      "<action event=\"update\" run=\"Chrome\"/>"
+      "<action event=\"postinstall\" osminversion=\"6.0\"/>"
+      "</actions>"
+      "</manifest>"
+      "</updatecheck><ping status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(0, service.number_of_tries_);
+  EXPECT_FALSE(service.current_ping_time_.is_null());
+  EXPECT_EQ(service.current_ping_time_, service.next_tries_time_);
+  EXPECT_GT(service.last_sent_time_, now);
+  EXPECT_TRUE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, SendPingFailure) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, version_info::GetVersionNumber());
+  net::TestURLFetcherFactory factory_;
+
+  // Tries with a non 200 result.
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+  base::Time next_tries_time = service.next_tries_time_;
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(400);
+  fetcher->SetResponseString("");
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_EQ(next_tries_time, service.next_tries_time_);
+  EXPECT_LT(service.last_sent_time_, now);
+  EXPECT_FALSE(NeedUpdate());
+
+  // Tries with an incorrect xml message.
+  service.SendPing();
+  EXPECT_EQ(2, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+  next_tries_time = service.next_tries_time_;
+
+  fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString("Incorrect Message");
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(2, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_EQ(next_tries_time, service.next_tries_time_);
+  EXPECT_LT(service.last_sent_time_, now);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, PersistStatesTest) {
+  std::string version_string = version_info::GetVersionNumber();
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  service.number_of_tries_ = 5;
+  service.last_sent_time_ = now - base::TimeDelta::FromSeconds(1);
+  service.next_tries_time_ = now + base::TimeDelta::FromSeconds(2);
+  service.current_ping_time_ = now + base::TimeDelta::FromSeconds(3);
+  service.last_sent_version_ = base::Version(version_string);
+  service.PersistStates();
+
+  OmahaService service2(false);
+  EXPECT_EQ(service.number_of_tries_, 5);
+  EXPECT_EQ(service2.last_sent_time_, now - base::TimeDelta::FromSeconds(1));
+  EXPECT_EQ(service2.next_tries_time_, now + base::TimeDelta::FromSeconds(2));
+  EXPECT_EQ(service2.current_ping_time_, now + base::TimeDelta::FromSeconds(3));
+  EXPECT_EQ(service.last_sent_version_.GetString(), version_string);
+}
+
+TEST_F(OmahaServiceTest, BackoffTest) {
+  for (int i = 1; i < 100; ++i) {
+    // Testing multiple times for a given number of retries, as the method has
+    // a random part.
+    for (int j = 0; j < 2; ++j) {
+      EXPECT_GE(OmahaService::GetBackOff(i).InSeconds(), 3600 - 360);
+      EXPECT_LE(OmahaService::GetBackOff(i).InSeconds(), 6 * 3600);
+    }
+  }
+}
+
+// Tests that an active ping is scheduled immediately after a successful install
+// event send.
+TEST_F(OmahaServiceTest, ActivePingAfterInstallEventTest) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, "");
+  net::TestURLFetcherFactory factory_;
+
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"0\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<event status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_LT(service.current_ping_time_ - now, base::TimeDelta::FromMinutes(1));
+  EXPECT_GT(service.next_tries_time_, service.current_ping_time_);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+// Tests that active pings are not sent in rapid succession.
+TEST_F(OmahaServiceTest, NonSpammingTest) {
+  base::Time now = base::Time::Now();
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, version_info::GetVersionNumber());
+  net::TestURLFetcherFactory factory_;
+
+  service.SendPing();
+  EXPECT_EQ(1, service.number_of_tries_);
+  EXPECT_TRUE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_, now + base::TimeDelta::FromMinutes(54));
+  EXPECT_LE(service.next_tries_time_, now + base::TimeDelta::FromHours(7));
+
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"0\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_EQ(0, service.number_of_tries_);
+  EXPECT_FALSE(service.current_ping_time_.is_null());
+  EXPECT_GE(service.next_tries_time_ - now, base::TimeDelta::FromHours(2));
+  EXPECT_GT(service.last_sent_time_, now);
+  EXPECT_FALSE(NeedUpdate());
+}
+
+TEST_F(OmahaServiceTest, InstallRetryTest) {
+  OmahaService service(false);
+  service.set_upgrade_recommended_callback(
+      base::Bind(&OmahaServiceTest::OnNeedUpdate, base::Unretained(this)));
+  CleanService(&service, "");
+  net::TestURLFetcherFactory factory_;
+
+  EXPECT_FALSE(service.IsNextPingInstallRetry());
+  std::string id1 = service.GetNextPingRequestId(OmahaService::INSTALL_EVENT);
+  EXPECT_TRUE(service.IsNextPingInstallRetry());
+  ASSERT_EQ(id1, service.GetNextPingRequestId(OmahaService::INSTALL_EVENT));
+
+  service.SendPing();
+  net::TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
+  DCHECK(fetcher);
+  DCHECK(fetcher->delegate());
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);
+  std::string response =
+      std::string(
+          "<?xml version=\"1.0\"?><response protocol=\"3.0\" server=\"prod\">"
+          "<daystart elapsed_seconds=\"56754\"/><app appid=\"") +
+      test_application_id_ +
+      "\" status=\"ok\">"
+      "<updatecheck status=\"noupdate\"/><ping status=\"ok\"/>"
+      "</app></response>";
+  fetcher->SetResponseString(response);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_FALSE(service.IsNextPingInstallRetry());
+  id1 = service.GetNextPingRequestId(OmahaService::USAGE_PING);
+  ASSERT_NE(id1, service.GetNextPingRequestId(OmahaService::USAGE_PING));
+}