[rac] Download country code data in a single HTTP request.

third_party/libaddressinput/chromium/cpp/test/fake_downloader_test.cc

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 45 matching lines @@
 };
 
 // Returns testing::AssertionSuccess if |data| is valid downloaded data for
 // |key|.
 testing::AssertionResult DataIsValid(const std::string& data,
                                      const std::string& key) {
   if (data.empty()) {
     return testing::AssertionFailure() << "empty data";
   }
 
-  std::string expected_data_begin = "{\"id\":\"" + key + "\"";
-  if (data.compare(0, expected_data_begin.length(), expected_data_begin) != 0) {
+  static const char kDataBegin[] = "{\"data/";
+  static const size_t kDataBeginLength = sizeof kDataBegin - 1;
+  if (data.compare(0, kDataBeginLength, kDataBegin, kDataBeginLength) != 0) {
     return testing::AssertionFailure() << data << " does not begin with "
-                                       << expected_data_begin;
+                                       << kDataBegin;
   }
 
-  static const char kDataEnd[] = "\"}";
+  static const char kDataEnd[] = "\"}}";
   static const size_t kDataEndLength = sizeof kDataEnd - 1;
   if (data.compare(data.length() - kDataEndLength,
                    kDataEndLength,
                    kDataEnd,
                    kDataEndLength) != 0) {
     return testing::AssertionFailure() << data << " does not end with "
                                        << kDataEnd;
   }
 
   return testing::AssertionSuccess();
 }
 
 // Verifies that FakeDownloader downloads valid data for a region code.
 TEST_P(FakeDownloaderTest, FakeDownloaderHasValidDataForRegion) {
   std::string key = "data/" + GetParam();
   std::string url = std::string(FakeDownloader::kFakeDataUrl) + key;
   downloader_.Download(url, BuildCallback());
 
   EXPECT_TRUE(success_);
   EXPECT_EQ(url, url_);
   EXPECT_TRUE(DataIsValid(data_, key));
 };
 
 // Test all region codes.
 INSTANTIATE_TEST_CASE_P(
     AllRegions, FakeDownloaderTest,
     testing::ValuesIn(RegionDataConstants::GetRegionCodes()));
 
-// Verifies that the key "data" also contains valid data.
-TEST_F(FakeDownloaderTest, DownloadExistingData) {
-  static const std::string kKey = "data";
-  static const std::string kUrl =
-      std::string(FakeDownloader::kFakeDataUrl) + kKey;
-  downloader_.Download(kUrl, BuildCallback());
-
-  EXPECT_TRUE(success_);
-  EXPECT_EQ(kUrl, url_);
-  EXPECT_TRUE(DataIsValid(data_, kKey));
-}
-
 // Verifies that downloading a missing key will return "{}".
 TEST_F(FakeDownloaderTest, DownloadMissingKeyReturnsEmptyDictionary) {
   static const std::string kJunkUrl =
       std::string(FakeDownloader::kFakeDataUrl) + "junk";
   downloader_.Download(kJunkUrl, BuildCallback());
 
   EXPECT_TRUE(success_);
   EXPECT_EQ(kJunkUrl, url_);
   EXPECT_EQ("{}", data_);
 }
@@ skipping 15 matching lines @@
 
   EXPECT_FALSE(success_);
   EXPECT_EQ(kRealUrl, url_);
   EXPECT_TRUE(data_.empty());
 }
 
 }  // namespace
 
 }  // namespace addressinput
 }  // namespace i18n