Issue 71980: Extensions code should use UTF-16 for user-visible Unicode strings

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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 82 matching lines @@
 const char* const theme_crx = "iamefpfkojoapidjnbafmgkgncegbkad";
 const char* const theme2_crx = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 const char* const permissions_crx = "eagpmdpfmaekmmcejjbmjoecnejeiiin";
 
 struct ExtensionsOrder {
   bool operator()(const Extension* a, const Extension* b) {
     return a->name() < b->name();
   }
 };
 
-static std::vector<std::string> GetErrors() {
-  const std::vector<std::string>* errors =
+static std::vector<string16> GetErrors() {
+  const std::vector<string16>* errors =
       ExtensionErrorReporter::GetInstance()->GetErrors();
-  std::vector<std::string> ret_val;
+  std::vector<string16> ret_val;
 
-  for (std::vector<std::string>::const_iterator iter = errors->begin();
+  for (std::vector<string16>::const_iterator iter = errors->begin();
        iter != errors->end(); ++iter) {
-    if (iter->find(".svn") == std::string::npos) {
+    std::string std_error = UTF16ToUTF8(*iter);
+    if (std_error.find(".svn") == std::string::npos) {
       ret_val.push_back(*iter);
     }
   }
 
   // The tests rely on the errors being in a certain order, which can vary
   // depending on how filesystem iteration works.
   std::stable_sort(ret_val.begin(), ret_val.end());
 
   return ret_val;
 }
@@ skipping 523 matching lines @@
     installer->InstallCrx(crx_path);
 
     return WaitForCrxInstall(crx_path, install_state);
   }
 
   // Wait for a CrxInstaller to finish. Used by InstallCRX.
   // Returns an Extension pointer if the install succeeded, NULL otherwise.
   const Extension* WaitForCrxInstall(const FilePath& path,
                                      InstallState install_state) {
     loop_.RunAllPending();
-    std::vector<std::string> errors = GetErrors();
+    std::vector<string16> errors = GetErrors();
     const Extension* extension = NULL;
     if (install_state != INSTALL_FAILED) {
       if (install_state == INSTALL_NEW)
         ++expected_extensions_count_;
 
       EXPECT_TRUE(installed_) << path.value();
 
       EXPECT_EQ(1u, loaded_.size()) << path.value();
       EXPECT_EQ(0u, errors.size()) << path.value();
       EXPECT_EQ(expected_extensions_count_, service_->extensions()->size()) <<
           path.value();
       extension = loaded_[0];
       EXPECT_TRUE(service_->GetExtensionById(extension->id(), false)) <<
           path.value();
-      for (std::vector<std::string>::iterator err = errors.begin();
+      for (std::vector<string16>::iterator err = errors.begin();
         err != errors.end(); ++err) {
         LOG(ERROR) << *err;
       }
     } else {
       EXPECT_FALSE(installed_) << path.value();
       EXPECT_EQ(0u, loaded_.size()) << path.value();
       EXPECT_EQ(1u, errors.size()) << path.value();
     }
 
     installed_ = NULL;
@@ skipping 22 matching lines @@
 
     int previous_enabled_extension_count =
         service_->extensions()->size();
     int previous_installed_extension_count =
         previous_enabled_extension_count +
         service_->disabled_extensions()->size();
 
     service_->UpdateExtension(id, path, GURL(), NULL);
     loop_.RunAllPending();
 
-    std::vector<std::string> errors = GetErrors();
+    std::vector<string16> errors = GetErrors();
     int error_count = errors.size();
     int enabled_extension_count =
         service_->extensions()->size();
     int installed_extension_count =
         enabled_extension_count + service_->disabled_extensions()->size();
 
     int expected_error_count = (expected_state == FAILED) ? 1 : 0;
     EXPECT_EQ(expected_error_count, error_count) << path.value();
 
     if (expected_state <= FAILED) {
@@ skipping 398 matching lines @@
       .DirName()
       .AppendASCII("Preferences");
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   service_->Init();
 
   ASSERT_EQ(4u, GetErrors().size());
   ASSERT_EQ(0u, loaded_.size());
 
-  EXPECT_TRUE(MatchPattern(GetErrors()[0],
+  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[0]),
       std::string("Could not load extension from '*'. ") +
-      extension_manifest_errors::kManifestUnreadable)) << GetErrors()[0];
+      extension_manifest_errors::kManifestUnreadable)) <<
+      UTF16ToUTF8(GetErrors()[0]);
 
-  EXPECT_TRUE(MatchPattern(GetErrors()[1],
+  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[1]),
       std::string("Could not load extension from '*'. ") +
-      extension_manifest_errors::kManifestUnreadable)) << GetErrors()[1];
+      extension_manifest_errors::kManifestUnreadable)) <<
+      UTF16ToUTF8(GetErrors()[1]);
 
-  EXPECT_TRUE(MatchPattern(GetErrors()[2],
+  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[2]),
       std::string("Could not load extension from '*'. ") +
-      extension_manifest_errors::kMissingFile)) << GetErrors()[2];
+      extension_manifest_errors::kMissingFile)) <<
+      UTF16ToUTF8(GetErrors()[2]);
 
-  EXPECT_TRUE(MatchPattern(GetErrors()[3],
+  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[3]),
       std::string("Could not load extension from '*'. ") +
-      extension_manifest_errors::kManifestUnreadable)) << GetErrors()[3];
+      extension_manifest_errors::kManifestUnreadable)) <<
+      UTF16ToUTF8(GetErrors()[3]);
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionServiceTest, CleanupOnStartup) {
   PluginService::GetInstance()->Init();
 
   FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
@@ skipping 255 matching lines @@
              .AppendASCII("user_script_basic.user.js");
 
   ASSERT_TRUE(file_util::PathExists(path));
   scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(service_, NULL));
   installer->set_allow_silent_install(true);
   installer->InstallUserScript(
       path,
       GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
 
   loop_.RunAllPending();
-  std::vector<std::string> errors = GetErrors();
+  std::vector<string16> errors = GetErrors();
   EXPECT_TRUE(installed_) << "Nothing was installed.";
   ASSERT_EQ(1u, loaded_.size()) << "Nothing was loaded.";
   EXPECT_EQ(0u, errors.size()) << "There were errors: "
                                << JoinString(errors, ',');
   EXPECT_TRUE(service_->GetExtensionById(loaded_[0]->id(), false)) <<
               path.value();
 
   installed_ = NULL;
   loaded_.clear();
   ExtensionErrorReporter::GetInstance()->ClearErrors();
@@ skipping 1083 matching lines @@
   blacklist.push_back(good1);
   service_->UpdateExtensionBlacklist(blacklist);
   // Make sure pref is updated
   loop_.RunAllPending();
 
   ValidateBooleanPref(good1, "blacklist", true);
 
   // Load extensions.
   service_->Init();
 
-  std::vector<std::string> errors = GetErrors();
-  for (std::vector<std::string>::iterator err = errors.begin();
+  std::vector<string16> errors = GetErrors();
+  for (std::vector<string16>::iterator err = errors.begin();
     err != errors.end(); ++err) {
     LOG(ERROR) << *err;
   }
   ASSERT_EQ(2u, loaded_.size());
 
   EXPECT_FALSE(service_->GetExtensionById(good1, true));
 }
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
@@ skipping 1755 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, INSTALL_NEW);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }