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

chrome/browser/extensions/api/web_request/web_request_api_helpers.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/extensions/api/web_request/web_request_api_helpers.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/string_util.h"
@@ skipping 603 matching lines @@
     const std::string& value) {
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     net::HttpRequestHeaders::Iterator modification(
         (*delta)->modified_request_headers);
     while (modification.GetNext()) {
       if (key == modification.name() && value == modification.value())
         return (*delta)->extension_id;
     }
   }
-  return "";
+  return std::string();
 }
 
 // Returns the extension ID of the first extension in |deltas| that removes the
 // request header identified by |key|.
 static std::string FindRemoveRequestHeader(
     const EventResponseDeltas& deltas,
     const std::string& key) {
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     std::vector<std::string>::iterator i;
     for (i = (*delta)->deleted_request_headers.begin();
          i != (*delta)->deleted_request_headers.end();
          ++i) {
       if (*i == key)
         return (*delta)->extension_id;
     }
   }
-  return "";
+  return std::string();
 }
 
 void MergeOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
     extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   EventResponseDeltas::const_iterator delta;
 
   // Here we collect which headers we have removed or set to new values
@@ skipping 156 matching lines @@
   return modified;
 }
 
 static bool DoesResponseCookieMatchFilter(net::ParsedCookie* cookie,
                                           FilterResponseCookie* filter) {
   if (!cookie->IsValid()) return false;
   if (!filter) return true;
   if (filter->name.get() && cookie->Name() != *filter->name) return false;
   if (filter->value.get() && cookie->Value() != *filter->value) return false;
   if (filter->expires.get()) {
-    std::string actual_value = cookie->HasExpires() ? cookie->Expires() : "";
+    std::string actual_value =
+        cookie->HasExpires() ? cookie->Expires() : std::string();
     if (actual_value != *filter->expires)
       return false;
   }
   if (filter->max_age.get()) {
-    std::string actual_value = cookie->HasMaxAge() ? cookie->MaxAge() : "";
+    std::string actual_value =
+        cookie->HasMaxAge() ? cookie->MaxAge() : std::string();
     if (actual_value != base::IntToString(*filter->max_age))
       return false;
   }
   if (filter->domain.get()) {
-    std::string actual_value = cookie->HasDomain() ? cookie->Domain() : "";
+    std::string actual_value =
+        cookie->HasDomain() ? cookie->Domain() : std::string();
     if (actual_value != *filter->domain)
       return false;
   }
   if (filter->path.get()) {
-    std::string actual_value = cookie->HasPath() ? cookie->Path() : "";
+    std::string actual_value =
+        cookie->HasPath() ? cookie->Path() : std::string();
     if (actual_value != *filter->path)
       return false;
   }
   if (filter->secure.get() && cookie->IsSecure() != *filter->secure)
     return false;
   if (filter->http_only.get() && cookie->IsHttpOnly() != *filter->http_only)
     return false;
   int64 seconds_till_expiry;
   bool lifetime_parsed = false;
   if (filter->age_upper_bound.get() ||
@@ skipping 28 matching lines @@
   EventResponseDeltas::const_reverse_iterator delta;
   for (delta = deltas.rbegin(); delta != deltas.rend(); ++delta) {
     const ResponseCookieModifications& modifications =
         (*delta)->response_cookie_modifications;
     for (ResponseCookieModifications::const_iterator mod =
              modifications.begin(); mod != modifications.end(); ++mod) {
       if ((*mod)->type != ADD || !(*mod)->modification.get())
         continue;
       // Cookie names are not unique in response cookies so we always append
       // and never override.
-      linked_ptr<net::ParsedCookie> cookie(new net::ParsedCookie(""));
+      linked_ptr<net::ParsedCookie> cookie(
+          new net::ParsedCookie(std::string()));
       ApplyResponseCookieModification((*mod)->modification.get(), cookie.get());
       cookies->push_back(cookie);
       modified = true;
     }
   }
   return modified;
 }
 
 // Applies all CookieModificationType::EDIT operations for response cookies of
 // |deltas| to |cookies|. Returns whether any cookie was modified.
@@ skipping 107 matching lines @@
   std::string lower_key = StringToLowerASCII(key);
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     ResponseHeaders::const_iterator i;
     for (i = (*delta)->deleted_response_headers.begin();
          i != (*delta)->deleted_response_headers.end(); ++i) {
       if (StringToLowerASCII(i->first) == lower_key)
         return (*delta)->extension_id;
     }
   }
-  return "";
+  return std::string();
 }
 
 void MergeOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     extensions::ExtensionWarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   EventResponseDeltas::const_iterator delta;
 
@@ skipping 144 matching lines @@
 void ClearCacheOnNavigation() {
   if (content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     ClearCacheOnNavigationOnUI();
   } else {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      base::Bind(&ClearCacheOnNavigationOnUI));
   }
 }
 
 }  // namespace extension_web_request_api_helpers