Rewrite std::string("") to std::string(), Linux edition.

chrome/browser/extensions/updater/extension_updater_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 <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 414 matching lines @@
 static void ExtractParameters(const std::string& params,
                               std::map<std::string, std::string>* result) {
   std::vector<std::string> pairs;
   base::SplitString(params, '&', &pairs);
   for (size_t i = 0; i < pairs.size(); i++) {
     std::vector<std::string> key_val;
     base::SplitString(pairs[i], '=', &key_val);
     if (!key_val.empty()) {
       std::string key = key_val[0];
       EXPECT_TRUE(result->find(key) == result->end());
-      (*result)[key] = (key_val.size() == 2) ? key_val[1] : "";
+      (*result)[key] = (key_val.size() == 2) ? key_val[1] : std::string();
     } else {
       NOTREACHED();
     }
   }
 }
 
 static void VerifyQueryAndExtractParameters(
     const std::string& query,
     std::map<std::string, std::string>* result) {
   std::map<std::string, std::string> params;
@@ skipping 184 matching lines @@
     EXPECT_TRUE(ContainsKey(params, "ping"));
   }
 
   void TestUpdateUrlDataEmpty() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an empty update URL data string does not cause a ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
-    fetch_data.AddExtension(id, version, &kNeverPingedData, "", "");
+    fetch_data.AddExtension(
+        id, version, &kNeverPingedData, std::string(), std::string());
 
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ(0U, params.count("ap"));
   }
 
   void TestUpdateUrlDataSimple() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
-    fetch_data.AddExtension(id, version, &kNeverPingedData, "bar", "");
+    fetch_data.AddExtension(
+        id, version, &kNeverPingedData, "bar", std::string());
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ("bar", params["ap"]);
   }
 
   void TestUpdateUrlDataCompound() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
-    fetch_data.AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c", "");
+    fetch_data.AddExtension(
+        id, version, &kNeverPingedData, "a=1&b=2&c", std::string());
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ("a%3D1%26b%3D2%26c", params["ap"]);
   }
 
   void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
     net::TestURLFetcherFactory factory;
 
@@ skipping 49 matching lines @@
     UpdateManifest::Results updates;
     std::vector<int> updateable;
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
     // installed and available at v2.0).
     const std::string id1 = id_util::GenerateId("1");
     const std::string id2 = id_util::GenerateId("2");
-    fetch_data.AddExtension(id1, "1.0.0.0",
-                            &kNeverPingedData, kEmptyUpdateUrlData, "");
-    AddParseResult(id1, "1.1",
-                   "http://localhost/e1_1.1.crx", &updates);
-    fetch_data.AddExtension(id2, "2.0.0.0",
-                            &kNeverPingedData, kEmptyUpdateUrlData, "");
-    AddParseResult(id2, "2.0.0.0",
-                   "http://localhost/e2_2.0.crx", &updates);
+    fetch_data.AddExtension(
+        id1, "1.0.0.0", &kNeverPingedData, kEmptyUpdateUrlData, std::string());
+    AddParseResult(id1, "1.1", "http://localhost/e1_1.1.crx", &updates);
+    fetch_data.AddExtension(
+        id2, "2.0.0.0", &kNeverPingedData, kEmptyUpdateUrlData, std::string());
+    AddParseResult(id2, "2.0.0.0", "http://localhost/e2_2.0.crx", &updates);
 
     EXPECT_CALL(delegate, IsExtensionPending(_)).WillRepeatedly(Return(false));
     EXPECT_CALL(delegate, GetExtensionExistingVersion(id1, _))
         .WillOnce(DoAll(SetArgPointee<1>("1.0.0.0"),
                         Return(true)));
     EXPECT_CALL(delegate, GetExtensionExistingVersion(id2, _))
         .WillOnce(DoAll(SetArgPointee<1>("2.0.0.0"),
                         Return(true)));
 
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
@@ skipping 16 matching lines @@
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     UpdateManifest::Results updates;
 
     std::list<std::string> ids_for_update_check;
     pending_extension_manager->GetPendingIdsForUpdateCheck(
         &ids_for_update_check);
 
     std::list<std::string>::const_iterator it;
     for (it = ids_for_update_check.begin();
          it != ids_for_update_check.end(); ++it) {
-      fetch_data.AddExtension(*it, "1.0.0.0",
-                              &kNeverPingedData, kEmptyUpdateUrlData, "");
+      fetch_data.AddExtension(*it,
+                              "1.0.0.0",
+                              &kNeverPingedData,
+                              kEmptyUpdateUrlData,
+                              std::string());
       AddParseResult(*it, "1.1", "http://localhost/e1_1.1.crx", &updates);
     }
 
     // The delegate will tell the downloader that all the extensions are
     // pending.
     EXPECT_CALL(delegate, IsExtensionPending(_)).WillRepeatedly(Return(true));
 
     std::vector<int> updateable;
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
     // All the apps should be updateable.
@@ skipping 12 matching lines @@
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     scoped_ptr<ManifestFetchData> fetch1(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch2(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch3(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch4(new ManifestFetchData(kUpdateUrl, 0));
     ManifestFetchData::PingData zeroDays(0, 0, true);
-    fetch1->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData, "");
-    fetch2->AddExtension("2222", "2.0", &zeroDays, kEmptyUpdateUrlData, "");
-    fetch3->AddExtension("3333", "3.0", &zeroDays, kEmptyUpdateUrlData, "");
-    fetch4->AddExtension("4444", "4.0", &zeroDays, kEmptyUpdateUrlData, "");
+    fetch1->AddExtension(
+        "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string());
+    fetch2->AddExtension(
+        "2222", "2.0", &zeroDays, kEmptyUpdateUrlData, std::string());
+    fetch3->AddExtension(
+        "3333", "3.0", &zeroDays, kEmptyUpdateUrlData, std::string());
+    fetch4->AddExtension(
+        "4444", "4.0", &zeroDays, kEmptyUpdateUrlData, std::string());
 
     // This will start the first fetcher and queue the others. The next in queue
     // is started as each fetcher receives its response.
     downloader.StartUpdateCheck(fetch1.Pass());
     downloader.StartUpdateCheck(fetch2.Pass());
     downloader.StartUpdateCheck(fetch3.Pass());
     downloader.StartUpdateCheck(fetch4.Pass());
     RunUntilIdle();
 
     // The first fetch will fail.
@@ skipping 87 matching lines @@
     NotificationsObserver observer;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     scoped_ptr<ManifestFetchData> fetch(new ManifestFetchData(kUpdateUrl, 0));
     ManifestFetchData::PingData zeroDays(0, 0, true);
-    fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData, "");
+    fetch->AddExtension(
+        "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string());
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(fetch.Pass());
     RunUntilIdle();
 
     // ExtensionDownloader should retry kMaxRetries times and then fail.
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     for (int i = 0; i <= ExtensionDownloader::kMaxRetries; ++i) {
       // All fetches will fail.
       fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
       EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
       fetcher->set_url(kUpdateUrl);
       fetcher->set_status(net::URLRequestStatus());
       // Code 5xx causes ExtensionDownloader to retry.
       fetcher->set_response_code(500);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
       RunUntilIdle();
     }
     Mock::VerifyAndClearExpectations(&delegate);
 
 
     // For response codes that are not in the 5xx range ExtensionDownloader
     // should not retry.
     fetch.reset(new ManifestFetchData(kUpdateUrl, 0));
-    fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData, "");
+    fetch->AddExtension(
+        "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string());
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(fetch.Pass());
     RunUntilIdle();
 
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     // The first fetch will fail, and require retrying.
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
@@ skipping 31 matching lines @@
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service->request_context()));
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    std::string hash = "";
+    std::string hash;
     Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
         new ExtensionDownloader::ExtensionFetch(
             id, test_url, hash, version.GetString(), requests));
     updater.downloader_->FetchUpdatedExtension(fetch.Pass());
 
     if (pending) {
       const bool kIsFromSync = true;
@@ skipping 115 matching lines @@
         &kNoBackoffPolicy);
 
     EXPECT_FALSE(updater.crx_install_is_running_);
 
     GURL url1("http://localhost/extension1.crx");
     GURL url2("http://localhost/extension2.crx");
 
     std::string id1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string id2 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
-    std::string hash1 = "";
-    std::string hash2 = "";
+    std::string hash1;
+    std::string hash2;
 
     std::string version1 = "0.1";
     std::string version2 = "0.1";
     std::set<int> requests;
     requests.insert(0);
     // Start two fetches
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch1(
         new ExtensionDownloader::ExtensionFetch(
             id1, url1, hash1, version1, requests));
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch2(
@@ skipping 193 matching lines @@
     // fetch.
     std::vector<GURL> fetched_urls;
     net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetched_urls.push_back(fetcher->GetOriginalURL());
 
     fetcher->set_url(fetched_urls[0]);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(500);
-    fetcher->SetResponseString("");
+    fetcher->SetResponseString(std::string());
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     fetched_urls.push_back(fetcher->GetOriginalURL());
 
     // The urls could have been fetched in either order, so use the host to
     // tell them apart and note the query each used.
     std::string url1_query;
     std::string url2_query;
     if (fetched_urls[0].host() == url1.host()) {
@@ skipping 64 matching lines @@
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), service.blacklist(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
 
     ManifestFetchData fetch_data(update_url, 0);
     const Extension* extension = tmp[0];
-    fetch_data.AddExtension(extension->id(), extension->VersionString(),
-                            &kNeverPingedData, kEmptyUpdateUrlData, "");
+    fetch_data.AddExtension(extension->id(),
+                            extension->VersionString(),
+                            &kNeverPingedData,
+                            kEmptyUpdateUrlData,
+                            std::string());
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
 
     updater.downloader_->HandleManifestResults(fetch_data, &results);
     Time last_ping_day =
         service.extension_prefs()->LastPingDay(extension->id());
     EXPECT_FALSE(last_ping_day.is_null());
     int64 seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
   }
@@ skipping 183 matching lines @@
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with invalid update URLs should be rejected.
   id = id_util::GenerateId("foo2");
   EXPECT_FALSE(
       downloader->AddPendingExtension(id, GURL("http:google.com:foo"), 0));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty IDs should be rejected.
-  EXPECT_FALSE(downloader->AddPendingExtension("", GURL(), 0));
+  EXPECT_FALSE(downloader->AddPendingExtension(std::string(), GURL(), 0));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // TODO(akalin): Test that extensions with empty update URLs
   // converted from user scripts are rejected.
 
   // Reset the ExtensionDownloader so that it drops the current fetcher.
   downloader.reset(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
@@ skipping 52 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions