Installer refactoring: using string16 instead of wstring for GoogleUpdateSettings.

chrome/installer/util/google_update_settings_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 "chrome/installer/util/google_update_settings.h"
+
 #include <windows.h>
 #include <shlwapi.h>  // For SHDeleteKey.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/win/registry.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/fake_installation_state.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_experiment_util.h"
-#include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::win::RegKey;
 using installer::ChannelInfo;
 
 namespace {
 
 const wchar_t kTestProductGuid[] = L"{89F1B351-B15D-48D4-8F10-1298721CF13D}";
@@ skipping 13 matching lines @@
     SYSTEM_INSTALL,
     USER_INSTALL,
   };
 
   void SetApField(SystemUserInstall is_system, const wchar_t* value) {
     HKEY root = is_system == SYSTEM_INSTALL ?
         HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
     RegKey update_key;
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-    std::wstring path = dist->GetStateKey();
+    base::string16 path = dist->GetStateKey();
     ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(), KEY_WRITE));
     ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value));
   }
 
   // Sets the "ap" field for a multi-install product (both the product and
   // the binaries).
   void SetMultiApField(SystemUserInstall is_system, const wchar_t* value) {
     // Caller must specify a multi-install ap value.
-    ASSERT_NE(std::wstring::npos, std::wstring(value).find(L"-multi"));
+    ASSERT_NE(base::string16::npos, base::string16(value).find(L"-multi"));
     HKEY root = is_system == SYSTEM_INSTALL ?
         HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
     RegKey update_key;
 
     // Write the ap value for both the product and the binaries.
     BrowserDistribution* const kDists[] = {
       BrowserDistribution::GetDistribution(),
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BINARIES)
     };
     for (size_t i = 0; i < arraysize(kDists); ++i) {
-      std::wstring path = kDists[i]->GetStateKey();
+      base::string16 path = kDists[i]->GetStateKey();
       ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(),
                                                  KEY_WRITE));
       ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value));
     }
 
     // Make the product technically multi-install.
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     ASSERT_EQ(ERROR_SUCCESS,
               update_key.Create(root, dist->GetStateKey().c_str(), KEY_WRITE));
     ASSERT_EQ(ERROR_SUCCESS,
@@ skipping 25 matching lines @@
     };
     const wchar_t* suffixes[] = {
       L"",
       L"suffix",
       L"suffix-with-dash",
     };
 
     for (size_t i = 0; i < arraysize(prefixes); ++i) {
       for (size_t j = 0; j < arraysize(expectations); ++j) {
         for (size_t k = 0; k < arraysize(suffixes); ++k) {
-          std::wstring ap = prefixes[i];
+          base::string16 ap = prefixes[i];
           ap += expectations[j].ap_value;
           ap += suffixes[k];
           const wchar_t* channel = expectations[j].channel;
 
           SetApField(install, ap.c_str());
           base::string16 ret_channel;
 
           EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(
               is_system, &ret_channel));
           EXPECT_STREQ(channel, ret_channel.c_str())
               << "Expecting channel \"" << channel
               << "\" for ap=\"" << ap << "\"";
         }
       }
     }
   }
 
   // Test the writing and deleting functionality of the experiments label
   // helper.
   void TestExperimentsLabelHelper(SystemUserInstall install) {
     BrowserDistribution* chrome =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
-    std::wstring value;
+    base::string16 value;
 #if defined(GOOGLE_CHROME_BUILD)
     EXPECT_TRUE(chrome->ShouldSetExperimentLabels());
 
     // Before anything is set, ReadExperimentLabels should succeed but return
     // an empty string.
     EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels(
         install == SYSTEM_INSTALL, &value));
     EXPECT_EQ(base::string16(), value);
 
     EXPECT_TRUE(GoogleUpdateSettings::SetExperimentLabels(
@@ skipping 30 matching lines @@
     key.Close();
 #else
     EXPECT_FALSE(chrome->ShouldSetExperimentLabels());
     EXPECT_FALSE(GoogleUpdateSettings::ReadExperimentLabels(
         install == SYSTEM_INSTALL, &value));
 #endif  // GOOGLE_CHROME_BUILD
   }
 
   // Creates "ap" key with the value given as parameter. Also adds work
   // items to work_item_list given so that they can be rolled back later.
-  bool CreateApKey(WorkItemList* work_item_list, const std::wstring& value) {
+  bool CreateApKey(WorkItemList* work_item_list, const base::string16& value) {
     HKEY reg_root = HKEY_CURRENT_USER;
-    std::wstring reg_key = GetApKeyPath();
+    base::string16 reg_key = GetApKeyPath();
     work_item_list->AddCreateRegKeyWorkItem(
         reg_root, reg_key, WorkItem::kWow64Default);
     work_item_list->AddSetRegValueWorkItem(reg_root,
                                            reg_key,
                                            WorkItem::kWow64Default,
                                            google_update::kRegApField,
                                            value.c_str(),
                                            true);
     if (!work_item_list->Do()) {
       work_item_list->Rollback();
       return false;
     }
     return true;
   }
 
   // Returns the key path of "ap" key, e.g.:
   // Google\Update\ClientState\<kTestProductGuid>
-  std::wstring GetApKeyPath() {
-    std::wstring reg_key(google_update::kRegPathClientState);
+  base::string16 GetApKeyPath() {
+    base::string16 reg_key(google_update::kRegPathClientState);
     reg_key.append(L"\\");
     reg_key.append(kTestProductGuid);
     return reg_key;
   }
 
   // Utility method to read "ap" key value
-  std::wstring ReadApKeyValue() {
+  base::string16 ReadApKeyValue() {
     RegKey key;
-    std::wstring ap_key_value;
-    std::wstring reg_key = GetApKeyPath();
+    base::string16 ap_key_value;
+    base::string16 reg_key = GetApKeyPath();
     if (key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS) ==
         ERROR_SUCCESS) {
       key.ReadValue(google_update::kRegApField, &ap_key_value);
     }
 
     return ap_key_value;
   }
 
   bool SetUpdatePolicyForAppGuid(const base::string16& app_guid,
                                  GoogleUpdateSettings::UpdatePolicy policy) {
@@ skipping 276 matching lines @@
   ASSERT_TRUE(CreateApKey(work_item_list.get(), L"-full"))
       << "Failed to create ap key.";
   GoogleUpdateSettings::UpdateInstallStatus(false, installer::FULL_ARCHIVE_TYPE,
                                             installer::FIRST_INSTALL_SUCCESS,
                                             kTestProductGuid);
   EXPECT_STREQ(ReadApKeyValue().c_str(), L"");
   work_item_list->Rollback();
 
   work_item_list.reset(WorkItem::CreateWorkItemList());
   // Test the case of when "ap" key doesnt exist at all
-  std::wstring ap_key_value = ReadApKeyValue();
-  std::wstring reg_key = GetApKeyPath();
+  base::string16 ap_key_value = ReadApKeyValue();
+  base::string16 reg_key = GetApKeyPath();
   HKEY reg_root = HKEY_CURRENT_USER;
   bool ap_key_deleted = false;
   RegKey key;
   if (key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS) !=
       ERROR_SUCCESS) {
     work_item_list->AddCreateRegKeyWorkItem(
         reg_root, reg_key, WorkItem::kWow64Default);
     ASSERT_TRUE(work_item_list->Do()) << "Failed to create ClientState key.";
   } else if (key.DeleteValue(google_update::kRegApField) == ERROR_SUCCESS) {
     ap_key_deleted = true;
@@ skipping 147 matching lines @@
                        static_cast<DWORD>(4)));
   is_overridden = true;
   EXPECT_EQ(GoogleUpdateSettings::kDefaultUpdatePolicy,
             GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid,
                                                      &is_overridden));
   EXPECT_FALSE(is_overridden);
 }
 
 // Test that an app-specific override is used if present.
 TEST_F(GoogleUpdateSettingsTest, GetAppUpdatePolicyAppOverride) {
-  std::wstring app_policy_value(
+  base::string16 app_policy_value(
       GoogleUpdateSettings::kUpdateOverrideValuePrefix);
   app_policy_value.append(kTestProductGuid);
 
   EXPECT_EQ(ERROR_SUCCESS,
             RegKey(HKEY_LOCAL_MACHINE, GoogleUpdateSettings::kPoliciesKey,
                    KEY_SET_VALUE).WriteValue(
                        GoogleUpdateSettings::kUpdatePolicyValue,
                        static_cast<DWORD>(1)));
   EXPECT_EQ(ERROR_SUCCESS,
             RegKey(HKEY_LOCAL_MACHINE, GoogleUpdateSettings::kPoliciesKey,
@@ skipping 327 matching lines @@
 // A value parameterized test for testing the stats collection consent setting.
 class CollectStatsConsent : public ::testing::TestWithParam<StatsState> {
  public:
   static void SetUpTestCase();
   static void TearDownTestCase();
  protected:
   virtual void SetUp() OVERRIDE;
   static void MakeChromeMultiInstall(HKEY root_key);
   static void ApplySetting(StatsState::StateSetting setting,
                            HKEY root_key,
-                           const std::wstring& reg_key);
+                           const base::string16& reg_key);
 
-  static std::wstring* chrome_version_key_;
-  static std::wstring* chrome_state_key_;
-  static std::wstring* chrome_state_medium_key_;
-  static std::wstring* binaries_state_key_;
-  static std::wstring* binaries_state_medium_key_;
+  static base::string16* chrome_version_key_;
+  static base::string16* chrome_state_key_;
+  static base::string16* chrome_state_medium_key_;
+  static base::string16* binaries_state_key_;
+  static base::string16* binaries_state_medium_key_;
   registry_util::RegistryOverrideManager override_manager_;
 };
 
-std::wstring* CollectStatsConsent::chrome_version_key_;
-std::wstring* CollectStatsConsent::chrome_state_key_;
-std::wstring* CollectStatsConsent::chrome_state_medium_key_;
-std::wstring* CollectStatsConsent::binaries_state_key_;
-std::wstring* CollectStatsConsent::binaries_state_medium_key_;
+base::string16* CollectStatsConsent::chrome_version_key_;
+base::string16* CollectStatsConsent::chrome_state_key_;
+base::string16* CollectStatsConsent::chrome_state_medium_key_;
+base::string16* CollectStatsConsent::binaries_state_key_;
+base::string16* CollectStatsConsent::binaries_state_medium_key_;
 
 void CollectStatsConsent::SetUpTestCase() {
   BrowserDistribution* dist =
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BROWSER);
-  chrome_version_key_ = new std::wstring(dist->GetVersionKey());
-  chrome_state_key_ = new std::wstring(dist->GetStateKey());
-  chrome_state_medium_key_ = new std::wstring(dist->GetStateMediumKey());
+  chrome_version_key_ = new base::string16(dist->GetVersionKey());
+  chrome_state_key_ = new base::string16(dist->GetStateKey());
+  chrome_state_medium_key_ = new base::string16(dist->GetStateMediumKey());
 
   dist = BrowserDistribution::GetSpecificDistribution(
       BrowserDistribution::CHROME_BINARIES);
-  binaries_state_key_ = new std::wstring(dist->GetStateKey());
-  binaries_state_medium_key_ = new std::wstring(dist->GetStateMediumKey());
+  binaries_state_key_ = new base::string16(dist->GetStateKey());
+  binaries_state_medium_key_ = new base::string16(dist->GetStateMediumKey());
 }
 
 void CollectStatsConsent::TearDownTestCase() {
   delete chrome_version_key_;
   delete chrome_state_key_;
   delete chrome_state_medium_key_;
   delete binaries_state_key_;
   delete binaries_state_medium_key_;
 }
 
 // Install the registry override and apply the settings to the registry.
 void CollectStatsConsent::SetUp() {
   const StatsState& stats_state = GetParam();
   const HKEY root_key = stats_state.root_key();
-  std::wstring reg_temp_name(stats_state.system_level() ? L"HKLM_" : L"HKCU_");
+  base::string16 reg_temp_name(
+      stats_state.system_level() ? L"HKLM_" : L"HKCU_");
   reg_temp_name += L"CollectStatsConsent";
   override_manager_.OverrideRegistry(root_key, reg_temp_name);
 
   if (stats_state.multi_install()) {
     MakeChromeMultiInstall(root_key);
     ApplySetting(stats_state.state_value(), root_key, *binaries_state_key_);
     ApplySetting(stats_state.state_medium_value(), root_key,
                  *binaries_state_medium_key_);
   } else {
     ApplySetting(stats_state.state_value(), root_key, *chrome_state_key_);
@@ skipping 13 matching lines @@
   ASSERT_EQ(
       ERROR_SUCCESS,
       RegKey(root_key, chrome_state_key_->c_str(),
              KEY_SET_VALUE).WriteValue(installer::kUninstallArgumentsField,
                                        L"--multi-install"));
 }
 
 // Write the correct value to represent |setting| in the registry.
 void CollectStatsConsent::ApplySetting(StatsState::StateSetting setting,
                                        HKEY root_key,
-                                       const std::wstring& reg_key) {
+                                       const base::string16& reg_key) {
   if (setting != StatsState::NO_SETTING) {
     DWORD value = setting != StatsState::FALSE_SETTING ? 1 : 0;
     ASSERT_EQ(
         ERROR_SUCCESS,
         RegKey(root_key, reg_key.c_str(),
                KEY_SET_VALUE).WriteValue(google_update::kRegUsageStatsField,
                                          value));
   }
 }
 
 // Test that stats consent can be read.
 TEST_P(CollectStatsConsent, GetCollectStatsConsentAtLevel) {
   if (GetParam().is_consent_granted()) {
     EXPECT_TRUE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel(
                     GetParam().system_level()));
   } else {
     EXPECT_FALSE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel(
                      GetParam().system_level()));
   }
 }
 
 // Test that stats consent can be flipped to the opposite setting, that the new
 // setting takes affect, and that the correct registry location is modified.
 TEST_P(CollectStatsConsent, SetCollectStatsConsentAtLevel) {
   EXPECT_TRUE(GoogleUpdateSettings::SetCollectStatsConsentAtLevel(
                   GetParam().system_level(),
                   !GetParam().is_consent_granted()));
-  const std::wstring* const reg_keys[] = {
+  const base::string16* const reg_keys[] = {
     chrome_state_key_,
     chrome_state_medium_key_,
     binaries_state_key_,
     binaries_state_medium_key_,
   };
   int key_index = ((GetParam().system_level() ? 1 : 0) +
                    (GetParam().multi_install() ? 2 : 0));
-  const std::wstring& reg_key = *reg_keys[key_index];
+  const base::string16& reg_key = *reg_keys[key_index];
   DWORD value = 0;
   EXPECT_EQ(
       ERROR_SUCCESS,
       RegKey(GetParam().root_key(), reg_key.c_str(),
              KEY_QUERY_VALUE).ReadValueDW(google_update::kRegUsageStatsField,
                                           &value));
   if (GetParam().is_consent_granted()) {
     EXPECT_FALSE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel(
                      GetParam().system_level()));
     EXPECT_EQ(0UL, value);
@@ skipping 61 matching lines @@
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::FALSE_SETTING, StatsState::FALSE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::FALSE_SETTING, StatsState::TRUE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::NO_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::FALSE_SETTING),
         StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
                    StatsState::TRUE_SETTING, StatsState::TRUE_SETTING)));