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

content/browser/gpu/gpu_control_list.cc

 // Copyright (c) 2013 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 "content/browser/gpu/gpu_control_list.h"
 
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 199 matching lines @@
     return kVersionStyleLexical;
   return kVersionStyleUnknown;
 }
 
 GpuControlList::OsInfo::OsInfo(const std::string& os,
                              const std::string& version_op,
                              const std::string& version_string,
                              const std::string& version_string2) {
   type_ = StringToOsType(os);
   if (type_ != kOsUnknown) {
-    version_info_.reset(
-        new VersionInfo(version_op, "", version_string, version_string2));
+    version_info_.reset(new VersionInfo(
+        version_op, std::string(), version_string, version_string2));
   }
 }
 
 GpuControlList::OsInfo::~OsInfo() {}
 
 bool GpuControlList::OsInfo::Contains(OsType type,
                                     const std::string& version) const {
   if (!IsValid())
     return false;
   if (type_ != type && type_ != kOsAny)
@@ skipping 26 matching lines @@
   return kOsUnknown;
 }
 
 GpuControlList::MachineModelInfo::MachineModelInfo(
     const std::string& name_op,
     const std::string& name_value,
     const std::string& version_op,
     const std::string& version_string,
     const std::string& version_string2) {
   name_info_.reset(new StringInfo(name_op, name_value));
-  version_info_.reset(
-      new VersionInfo(version_op, "", version_string, version_string2));
+  version_info_.reset(new VersionInfo(
+      version_op, std::string(), version_string, version_string2));
 }
 
 GpuControlList::MachineModelInfo::~MachineModelInfo() {}
 
 bool GpuControlList::MachineModelInfo::Contains(
     const std::string& name, const std::string& version) const {
   if (!IsValid())
     return false;
   if (!name_info_->Contains(name))
     return false;
@@ skipping 577 matching lines @@
   driver_version_info_.reset(new VersionInfo(
       version_op, version_style, version_string, version_string2));
   return driver_version_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetDriverDateInfo(
     const std::string& date_op,
     const std::string& date_string,
     const std::string& date_string2) {
   driver_date_info_.reset(
-      new VersionInfo(date_op, "", date_string, date_string2));
+      new VersionInfo(date_op, std::string(), date_string, date_string2));
   return driver_date_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLVendorInfo(
     const std::string& vendor_op,
     const std::string& vendor_value) {
   gl_vendor_info_.reset(new StringInfo(vendor_op, vendor_value));
   return gl_vendor_info_->IsValid();
 }
 
@@ skipping 463 matching lines @@
   DCHECK(value);
   const base::DictionaryValue* browser_version_value = NULL;
   if (value->GetDictionary("browser_version", &browser_version_value)) {
     std::string version_op = "any";
     std::string version_string;
     std::string version_string2;
     browser_version_value->GetString(kOp, &version_op);
     browser_version_value->GetString("number", &version_string);
     browser_version_value->GetString("number2", &version_string2);
     scoped_ptr<VersionInfo> browser_version_info;
-    browser_version_info.reset(
-        new VersionInfo(version_op, "", version_string, version_string2));
+    browser_version_info.reset(new VersionInfo(
+        version_op, std::string(), version_string, version_string2));
     if (!browser_version_info->IsValid())
       return kMalformed;
     if (browser_version_info->Contains(browser_version_))
       return kSupported;
     return kUnsupported;
   }
   return kSupported;
 }
 
 // static
@@ skipping 20 matching lines @@
     const std::string& feature_name, int feature_id) {
   feature_map_[feature_name] = feature_id;
 }
 
 void GpuControlList::set_supports_feature_type_all(bool supported) {
   supports_feature_type_all_ = supported;
 }
 
 }  // namespace content