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

chrome/common/extensions/features/simple_feature.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/common/extensions/features/simple_feature.h"
 
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 150 matching lines @@
       return "legacy packaged app";
     case Manifest::TYPE_PLATFORM_APP:
       return "packaged app";
     case Manifest::TYPE_THEME:
       return "theme";
     case Manifest::TYPE_USER_SCRIPT:
       return "user script";
   }
 
   NOTREACHED();
-  return "";
+  return std::string();
 }
 
 }  // namespace
 
 SimpleFeature::SimpleFeature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0),
     channel_(VersionInfo::CHANNEL_UNKNOWN) {
@@ skipping 40 matching lines @@
                       g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
   ParseEnum<VersionInfo::Channel>(
       value, "channel", &channel_,
       g_mappings.Get().channels);
   if (matches_.is_empty() && contexts_.count(WEB_PAGE_CONTEXT) != 0) {
     return name() + ": Allowing web_page contexts requires supplying a value " +
         "for matches.";
   }
-  return "";
+  return std::string();
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
     Manifest::Type type,
     Location location,
     int manifest_version,
     Platform platform) const {
   // Component extensions can access any feature.
   if (location == COMPONENT_LOCATION)
@@ skipping 63 matching lines @@
   if (!matches_.is_empty() && !matches_.MatchesURL(url))
     return CreateAvailability(INVALID_URL, url);
 
   return CreateAvailability(IS_AVAILABLE);
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
     AvailabilityResult result, Manifest::Type type, const GURL& url) const {
   switch (result) {
     case IS_AVAILABLE:
-      return "";
+      return std::string();
     case NOT_FOUND_IN_WHITELIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
     case INVALID_URL:
       CHECK(url.is_valid());
       return base::StringPrintf("'%s' is not allowed on %s.",
                                 name().c_str(), url.spec().c_str());
     case INVALID_TYPE: {
       std::string allowed_type_names;
@@ skipping 47 matching lines @@
     case UNSUPPORTED_CHANNEL:
       return base::StringPrintf(
           "'%s' requires Google Chrome %s channel or newer, and this is the "
               "%s channel.",
           name().c_str(),
           GetChannelName(channel_).c_str(),
           GetChannelName(GetCurrentChannel()).c_str());
   }
 
   NOTREACHED();
-  return "";
+  return std::string();
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL()));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result, Manifest::Type type) const {
@@ skipping 42 matching lines @@
   DCHECK(id_hash.length() == base::kSHA1Length);
   const std::string hexencoded_id_hash = base::HexEncode(id_hash.c_str(),
       id_hash.length());
   if (whitelist_.find(hexencoded_id_hash) != whitelist_.end())
     return true;
 
   return false;
 }
 
 }  // namespace extensions