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

chrome/browser/extensions/extension_service_unittest.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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 1174 matching lines @@
   EXPECT_TRUE(resource10.ComparePathWithDefault(expected_path));
 
   expected_patterns.ClearPatterns();
   AddPattern(&expected_patterns, "http://*.google.com/*");
   AddPattern(&expected_patterns, "https://*.google.com/*");
   EXPECT_EQ(expected_patterns,
             extension->GetActivePermissions()->explicit_hosts());
 
   EXPECT_EQ(std::string(good1), loaded_[1]->id());
   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
-  EXPECT_EQ(std::string(""), loaded_[1]->description());
+  EXPECT_EQ(std::string(), loaded_[1]->description());
   EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
             extensions::BackgroundInfo::GetBackgroundURL(loaded_[1]));
   EXPECT_EQ(
       0u, extensions::ContentScriptsInfo::GetContentScripts(loaded_[1]).size());
 
   // We don't parse the plugins section on Chrome OS.
 #if defined(OS_CHROMEOS)
   EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(loaded_[1]));
 #else
   ASSERT_TRUE(extensions::PluginInfo::HasPlugins(loaded_[1]));
   const std::vector<extensions::PluginInfo>* plugins =
       extensions::PluginInfo::GetPlugins(loaded_[1]);
   ASSERT_TRUE(plugins);
   ASSERT_EQ(2u, plugins->size());
   EXPECT_EQ(loaded_[1]->path().AppendASCII("content_plugin.dll").value(),
             plugins->at(0).path.value());
   EXPECT_TRUE(plugins->at(0).is_public);
   EXPECT_EQ(loaded_[1]->path().AppendASCII("extension_plugin.dll").value(),
             plugins->at(1).path.value());
   EXPECT_FALSE(plugins->at(1).is_public);
 #endif
 
   EXPECT_EQ(Manifest::INTERNAL, loaded_[1]->location());
 
   int index = expected_num_extensions - 1;
   EXPECT_EQ(std::string(good2), loaded_[index]->id());
   EXPECT_EQ(std::string("My extension 3"), loaded_[index]->name());
-  EXPECT_EQ(std::string(""), loaded_[index]->description());
+  EXPECT_EQ(std::string(), loaded_[index]->description());
   EXPECT_EQ(
       0u,
       extensions::ContentScriptsInfo::GetContentScripts(loaded_[index]).size());
   EXPECT_EQ(Manifest::INTERNAL, loaded_[index]->location());
 };
 
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
   // Initialize the test dir with a bad Preferences/extensions.
   base::FilePath source_install_dir = data_dir_
@@ skipping 2072 matching lines @@
 
   // Create a fake extension to be loaded as though it were read from prefs.
   base::FilePath path = data_dir_.AppendASCII("management")
                            .AppendASCII("simple_extension");
   DictionaryValue manifest;
   manifest.SetString(keys::kName, "simple_extension");
   manifest.SetString(keys::kVersion, "1");
   // UNPACKED is for extensions loaded from a directory. We use it here, even
   // though we're testing loading from prefs, so that we don't need to provide
   // an extension key.
-  extensions::ExtensionInfo extension_info(&manifest, "", path,
-                                           Manifest::UNPACKED);
+  extensions::ExtensionInfo extension_info(
+      &manifest, std::string(), path, Manifest::UNPACKED);
 
   // Ensure we can load it with no management policy in place.
   management_policy_->UnregisterAllProviders();
   EXPECT_EQ(0u, service_->extensions()->size());
   extensions::InstalledLoader(service_).Load(extension_info, false);
   EXPECT_EQ(1u, service_->extensions()->size());
 
   const Extension* extension = *(service_->extensions()->begin());
   EXPECT_TRUE(service_->UninstallExtension(extension->id(), false, NULL));
   EXPECT_EQ(0u, service_->extensions()->size());
@@ skipping 2573 matching lines @@
   EXPECT_FALSE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
 
   ExtensionPrefs* prefs = service_->extension_prefs();
   EXPECT_NE(0, prefs->GetDisableReasons(good_crx) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
   EXPECT_EQ(0, prefs->GetDisableReasons(page_action) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
 }