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

chrome/browser/extensions/api/declarative/initializing_rules_registry.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/declarative/initializing_rules_registry.h"
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 
@@ skipping 21 matching lines @@
   return delegate_->AddRules(extension_id, rules);
 }
 
 std::string InitializingRulesRegistry::RemoveRules(
     const std::string& extension_id,
     const std::vector<std::string>& rule_identifiers) {
   std::string error = delegate_->RemoveRules(extension_id, rule_identifiers);
   if (!error.empty())
     return error;
   RemoveUsedRuleIdentifiers(extension_id, rule_identifiers);
-  return "";
+  return std::string();
 }
 
 std::string InitializingRulesRegistry::RemoveAllRules(
     const std::string& extension_id) {
   std::string error = delegate_->RemoveAllRules(extension_id);
   if (!error.empty())
     return error;
   RemoveAllUsedRuleIdentifiers(extension_id);
-  return "";
+  return std::string();
 }
 
 std::string InitializingRulesRegistry::GetRules(
     const std::string& extension_id,
     const std::vector<std::string>& rule_identifiers,
     std::vector<linked_ptr<RulesRegistry::Rule> >* out) {
   return delegate_->GetRules(extension_id, rule_identifiers, out);
 }
 
 std::string InitializingRulesRegistry::GetAllRules(
@@ skipping 53 matching lines @@
   // Now we generate IDs in case they were not specificed in the rules. This
   // cannot fail so we do not need to keep track of a rollback log.
   for (std::vector<linked_ptr<RulesRegistry::Rule> >::const_iterator i =
       rules.begin(); i != rules.end(); ++i) {
     RulesRegistry::Rule* rule = i->get();
     if (!rule->id.get()) {
       rule->id.reset(new std::string(GenerateUniqueId(extension_id)));
       used_rule_identifiers_[extension_id].insert(*(rule->id));
     }
   }
-  return "";
+  return std::string();
 }
 
 void InitializingRulesRegistry::FillInOptionalPriorities(
     const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) {
   std::vector<linked_ptr<RulesRegistry::Rule> >::const_iterator i;
   for (i = rules.begin(); i != rules.end(); ++i) {
     if (!(*i)->priority.get())
       (*i)->priority.reset(new int(DEFAULT_PRIORITY));
   }
 }
 
 void InitializingRulesRegistry::RemoveUsedRuleIdentifiers(
     const std::string& extension_id,
     const std::vector<std::string>& identifiers) {
   std::vector<std::string>::const_iterator i;
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void InitializingRulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions