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

remoting/host/policy_hack/policy_watcher_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/policy_hack/fake_policy_watcher.h"
@@ skipping 11 matching lines @@
   }
 
   virtual void SetUp() OVERRIDE {
     message_loop_proxy_ = base::MessageLoopProxy::current();
     policy_callback_ = base::Bind(&MockPolicyCallback::OnPolicyUpdate,
                                   base::Unretained(&mock_policy_callback_));
     policy_watcher_.reset(new FakePolicyWatcher(message_loop_proxy_));
     nat_true_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
     nat_false_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
     nat_one_.SetInteger(PolicyWatcher::kNatPolicyName, 1);
-    domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, "");
+    domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
+                            std::string());
     domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName, kHostDomain);
     SetDefaults(nat_true_others_default_);
     nat_true_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
     SetDefaults(nat_false_others_default_);
     nat_false_others_default_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
     SetDefaults(domain_empty_others_default_);
     domain_empty_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName,
-                                           "");
+                                           std::string());
     SetDefaults(domain_full_others_default_);
     domain_full_others_default_.SetString(PolicyWatcher::kHostDomainPolicyName,
                                           kHostDomain);
     nat_true_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
-    nat_true_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, "");
+    nat_true_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
+                                     std::string());
     nat_true_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
     nat_true_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName,
                                    kHostDomain);
     nat_false_domain_empty_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
-    nat_false_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName, "");
+    nat_false_domain_empty_.SetString(PolicyWatcher::kHostDomainPolicyName,
+                                      std::string());
     nat_false_domain_full_.SetBoolean(PolicyWatcher::kNatPolicyName, false);
     nat_false_domain_full_.SetString(PolicyWatcher::kHostDomainPolicyName,
                                     kHostDomain);
     SetDefaults(nat_true_domain_empty_others_default_);
     nat_true_domain_empty_others_default_.SetBoolean(
         PolicyWatcher::kNatPolicyName, true);
     nat_true_domain_empty_others_default_.SetString(
-        PolicyWatcher::kHostDomainPolicyName, "");
-    unknown_policies_.SetString("UnknownPolicyOne", "");
-    unknown_policies_.SetString("UnknownPolicyTwo", "");
+        PolicyWatcher::kHostDomainPolicyName, std::string());
+    unknown_policies_.SetString("UnknownPolicyOne", std::string());
+    unknown_policies_.SetString("UnknownPolicyTwo", std::string());
 
     const char kOverrideNatTraversalToFalse[] =
       "{ \"RemoteAccessHostFirewallTraversal\": false }";
     nat_true_and_overridden_.SetBoolean(PolicyWatcher::kNatPolicyName, true);
     nat_true_and_overridden_.SetString(
         PolicyWatcher::kHostDebugOverridePoliciesName,
         kOverrideNatTraversalToFalse);
 #if !defined(NDEBUG)
     SetDefaults(nat_false_overridden_others_default_);
     nat_false_overridden_others_default_.SetBoolean(
@@ skipping 39 matching lines @@
   base::DictionaryValue nat_false_domain_full_;
   base::DictionaryValue nat_true_domain_empty_others_default_;
   base::DictionaryValue unknown_policies_;
   base::DictionaryValue nat_true_and_overridden_;
   base::DictionaryValue nat_false_overridden_others_default_;
 
  private:
   void SetDefaults(base::DictionaryValue& dict) {
     dict.SetBoolean(PolicyWatcher::kNatPolicyName, true);
     dict.SetBoolean(PolicyWatcher::kHostRequireTwoFactorPolicyName, false);
-    dict.SetString(PolicyWatcher::kHostDomainPolicyName, "");
+    dict.SetString(PolicyWatcher::kHostDomainPolicyName, std::string());
     dict.SetBoolean(PolicyWatcher::kHostMatchUsernamePolicyName, false);
     dict.SetString(PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
                    kDefaultHostTalkGadgetPrefix);
     dict.SetBoolean(PolicyWatcher::kHostRequireCurtainPolicyName, false);
-    dict.SetString(PolicyWatcher::kHostTokenUrlPolicyName, "");
-    dict.SetString(PolicyWatcher::kHostTokenValidationUrlPolicyName, "");
+    dict.SetString(PolicyWatcher::kHostTokenUrlPolicyName, std::string());
+    dict.SetString(PolicyWatcher::kHostTokenValidationUrlPolicyName,
+                   std::string());
 #if !defined(NDEBUG)
     dict.SetString(PolicyWatcher::kHostDebugOverridePoliciesName, "");
 #endif
   }
 };
 
 const char* PolicyWatcherTest::kHostDomain = "google.com";
 
 MATCHER_P(IsPolicies, dict, "") {
   return arg->Equals(dict);
@@ skipping 162 matching lines @@
       OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 #endif
 
   StartWatching();
   policy_watcher_->SetPolicies(&nat_true_and_overridden_);
   StopWatching();
 }
 
 }  // namespace policy_hack
 }  // namespace remoting