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

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings/content_settings_pref_provider.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 170 matching lines @@
   DCHECK(prefs_);
 
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
   std::vector<Rule> rules_to_delete;
   {
     base::AutoLock auto_lock(lock_);
     scoped_ptr<RuleIterator> rule_iterator(
-        map_to_modify->GetRuleIterator(content_type, "", NULL));
+        map_to_modify->GetRuleIterator(content_type, std::string(), NULL));
     // Copy the rules; we cannot call |UpdatePref| while holding |lock_|.
     while (rule_iterator->HasNext())
       rules_to_delete.push_back(rule_iterator->Next());
 
-    map_to_modify->DeleteValues(content_type, "");
+    map_to_modify->DeleteValues(content_type, std::string());
   }
 
   for (std::vector<Rule>::const_iterator it = rules_to_delete.begin();
        it != rules_to_delete.end(); ++it) {
-    UpdatePref(
-        it->primary_pattern,
-        it->secondary_pattern,
-        content_type,
-        "",
-        NULL);
+    UpdatePref(it->primary_pattern,
+               it->secondary_pattern,
+               content_type,
+               std::string(),
+               NULL);
   }
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   content_type,
                   std::string());
 }
 
 PrefProvider::~PrefProvider() {
   DCHECK(!prefs_);
 }
@@ skipping 83 matching lines @@
             pattern_str, NULL);
       }
     }
   }
 }
 
 
 void PrefProvider::MigrateObsoleteMediaContentSetting() {
   std::vector<Rule> rules_to_delete;
   {
-    scoped_ptr<RuleIterator> rule_iterator(
-        GetRuleIterator(CONTENT_SETTINGS_TYPE_MEDIASTREAM, "", false));
+    scoped_ptr<RuleIterator> rule_iterator(GetRuleIterator(
+        CONTENT_SETTINGS_TYPE_MEDIASTREAM, std::string(), false));
     while (rule_iterator->HasNext()) {
       // Skip default setting and rules without a value.
       const content_settings::Rule& rule = rule_iterator->Next();
       DCHECK(rule.primary_pattern != ContentSettingsPattern::Wildcard());
       if (!rule.value.get())
         continue;
       rules_to_delete.push_back(rule);
     }
   }
 
   for (std::vector<Rule>::const_iterator it = rules_to_delete.begin();
        it != rules_to_delete.end(); ++it) {
     const DictionaryValue* value_dict = NULL;
     if (!it->value->GetAsDictionary(&value_dict) || value_dict->empty())
       return;
 
     std::string audio_device, video_device;
     value_dict->GetString(kAudioKey, &audio_device);
     value_dict->GetString(kVideoKey, &video_device);
     // Add the exception to the new microphone content setting.
     if (!audio_device.empty()) {
       SetWebsiteSetting(it->primary_pattern,
                         it->secondary_pattern,
                         CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                        "",
+                        std::string(),
                         Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
     }
     // Add the exception to the new camera content setting.
     if (!video_device.empty()) {
       SetWebsiteSetting(it->primary_pattern,
                         it->secondary_pattern,
                         CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                        "",
+                        std::string(),
                         Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
     }
 
     // Remove the old exception in CONTENT_SETTINGS_TYPE_MEDIASTREAM.
     SetWebsiteSetting(it->primary_pattern,
                       it->secondary_pattern,
                       CONTENT_SETTINGS_TYPE_MEDIASTREAM,
-                      "",
+                      std::string(),
                       NULL);
   }
 }
 
 void PrefProvider::ReadContentSettingsFromPref(bool overwrite) {
   // |DictionaryPrefUpdate| sends out notifications when destructed. This
   // construction order ensures |AutoLock| gets destroyed first and |lock_| is
   // not held when the notifications are sent. Also, |auto_reset| must be still
   // valid when the notifications are sent, so that |Observe| skips the
   // notification.
@@ skipping 85 matching lines @@
                                                 ContentSetting(setting));
           value = Value::CreateIntegerValue(setting);
         }
       }
 
       // |value_map_| will take the ownership of |value|.
       if (value != NULL) {
         value_map_.SetValue(pattern_pair.first,
                             pattern_pair.second,
                             content_type,
-                            ResourceIdentifier(""),
+                            ResourceIdentifier(),
                             value);
         if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
           ContentSetting s = ValueToContentSetting(value);
           switch (s) {
             case CONTENT_SETTING_ALLOW :
               ++cookies_allow_exception_count;
               break;
             case CONTENT_SETTING_BLOCK :
               ++cookies_block_exception_count;
               break;
@@ skipping 95 matching lines @@
 
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings