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

chrome/service/cloud_print/cloud_print_proxy.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/service/cloud_print/cloud_print_proxy.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
@@ skipping 67 matching lines @@
   client_ = client;
 }
 
 void CloudPrintProxy::EnableForUser(const std::string& lsid) {
   DCHECK(CalledOnValidThread());
   if (!CreateBackend())
     return;
   DCHECK(backend_.get());
   // Read persisted robot credentials because we may decide to reuse it if the
   // passed in LSID belongs the same user.
-  std::string robot_refresh_token =
-      service_prefs_->GetString(prefs::kCloudPrintRobotRefreshToken, "");
+  std::string robot_refresh_token = service_prefs_->GetString(
+      prefs::kCloudPrintRobotRefreshToken, std::string());
   std::string robot_email =
-      service_prefs_->GetString(prefs::kCloudPrintRobotEmail, "");
+      service_prefs_->GetString(prefs::kCloudPrintRobotEmail, std::string());
   user_email_ = service_prefs_->GetString(prefs::kCloudPrintEmail, user_email_);
 
   // If we have been passed in an LSID, we want to use this to authenticate.
   // Else we will try and retrieve the last used auth tokens from prefs.
   if (!lsid.empty()) {
     backend_->InitializeWithLsid(lsid, robot_refresh_token, robot_email,
                                  user_email_);
   } else {
     // See if we have persisted robot credentials.
     if (!robot_refresh_token.empty()) {
       DCHECK(!robot_email.empty());
       backend_->InitializeWithRobotToken(robot_refresh_token, robot_email);
     } else {
       // Finally see if we have persisted user credentials (legacy case).
       std::string cloud_print_token =
-          service_prefs_->GetString(prefs::kCloudPrintAuthToken, "");
+          service_prefs_->GetString(prefs::kCloudPrintAuthToken, std::string());
       DCHECK(!cloud_print_token.empty());
       backend_->InitializeWithToken(cloud_print_token);
     }
   }
   if (client_) {
     client_->OnCloudPrintProxyEnabled(true);
   }
 }
 
 void CloudPrintProxy::EnableForUserWithRobot(
     const std::string& robot_auth_code,
     const std::string& robot_email,
     const std::string& user_email,
     bool connect_new_printers,
     const std::vector<std::string>& printer_blacklist) {
   DCHECK(CalledOnValidThread());
 
   ShutdownBackend();
   std::string proxy_id(
-      service_prefs_->GetString(prefs::kCloudPrintProxyId, ""));
+      service_prefs_->GetString(prefs::kCloudPrintProxyId, std::string()));
   service_prefs_->RemovePref(prefs::kCloudPrintRoot);
   if (!proxy_id.empty()) {
     // Keep only proxy id;
     service_prefs_->SetString(prefs::kCloudPrintProxyId, proxy_id);
   }
   service_prefs_->SetBoolean(prefs::kCloudPrintConnectNewPrinters,
                              connect_new_printers);
   if (!printer_blacklist.empty()) {
     scoped_ptr<base::ListValue> printers(new base::ListValue());
     printers->AppendStrings(printer_blacklist);
@@ skipping 59 matching lines @@
 
 void CloudPrintProxy::GetProxyInfo(CloudPrintProxyInfo* info) {
   info->enabled = enabled_;
   info->email.clear();
   if (enabled_)
     info->email = user_email();
   info->proxy_id = settings_.proxy_id();
   // If the Cloud Print service is not enabled, we may need to read the old
   // value of proxy_id from prefs.
   if (info->proxy_id.empty())
-    info->proxy_id = service_prefs_->GetString(prefs::kCloudPrintProxyId, "");
+    info->proxy_id =
+        service_prefs_->GetString(prefs::kCloudPrintProxyId, std::string());
 }
 
 void CloudPrintProxy::CheckCloudPrintProxyPolicy() {
   g_service_process->io_thread()->message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(&CheckCloudPrintProxyPolicyInBrowser));
 }
 
 void CloudPrintProxy::OnAuthenticated(
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email,
@@ skipping 55 matching lines @@
 }
 
 void CloudPrintProxy::ShutdownBackend() {
   DCHECK(CalledOnValidThread());
   if (backend_.get())
     backend_->Shutdown();
   backend_.reset();
 }
 
 }  // namespace cloud_print