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

chrome/common/extensions/api/extension_api.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/api/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 408 matching lines @@
   std::string feature_name;
   SplitDependencyName(full_name, &feature_type, &feature_name);
 
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(feature_name, &child_name);
 
   Feature* feature = GetFeatureDependency(full_name);
 
   // Check APIs not using the feature system first.
   if (!feature) {
-    return IsNonFeatureAPIAvailable(api_name, context, extension, url) ?
-        Feature::CreateAvailability(Feature::IS_AVAILABLE, "") :
-        Feature::CreateAvailability(Feature::INVALID_CONTEXT,
-                                    kUnavailableMessage);
+    return IsNonFeatureAPIAvailable(api_name, context, extension, url)
+               ? Feature::CreateAvailability(Feature::IS_AVAILABLE,
+                                             std::string())
+               : Feature::CreateAvailability(Feature::INVALID_CONTEXT,
+                                             kUnavailableMessage);
   }
 
   Feature::Availability availability =
       feature->IsAvailableToContext(extension, context, url);
   if (!availability.is_available())
     return availability;
 
   for (std::set<std::string>::iterator iter = feature->dependencies().begin();
        iter != feature->dependencies().end(); ++iter) {
     Feature::Availability dependency_availability =
         IsAvailable(*iter, extension, context, url);
     if (!dependency_availability.is_available())
       return dependency_availability;
   }
 
-  return Feature::CreateAvailability(Feature::IS_AVAILABLE, "");
+  return Feature::CreateAvailability(Feature::IS_AVAILABLE, std::string());
 }
 
 bool ExtensionAPI::IsPrivileged(const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
   Feature* feature = GetFeatureDependency(full_name);
 
   // First try to use the feature system.
   if (feature) {
     // An API is 'privileged' if it can only be run in a blessed context.
@@ skipping 168 matching lines @@
     }
 
     size_t last_dot_index = api_name_candidate.rfind('.');
     if (last_dot_index == std::string::npos)
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
-  return "";
+  return std::string();
 }
 
 bool ExtensionAPI::IsAPIAllowed(const std::string& name,
                                 const Extension* extension) {
   return extension->required_permission_set()->HasAnyAccessToAPI(name) ||
       extension->optional_permission_set()->HasAnyAccessToAPI(name);
 }
 
 bool ExtensionAPI::IsPrivilegedAPI(const std::string& name) {
   return completely_unprivileged_apis_.count(name) ||
       partially_unprivileged_apis_.count(name);
 }
 
 }  // namespace extensions