Add base:: to string16s in chrome/.

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 <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"
@@ skipping 84 matching lines @@
 
     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];
           ap += expectations[j].ap_value;
           ap += suffixes[k];
           const wchar_t* channel = expectations[j].channel;
 
           SetApField(install, ap.c_str());
-          string16 ret_channel;
+          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;
 #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(string16(), value);
+    EXPECT_EQ(base::string16(), value);
 
     EXPECT_TRUE(GoogleUpdateSettings::SetExperimentLabels(
         install == SYSTEM_INSTALL, kTestExperimentLabel));
 
     // Validate that something is written. Only worry about the label itself.
     RegKey key;
     HKEY root = install == SYSTEM_INSTALL ?
         HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-    string16 state_key = install == SYSTEM_INSTALL ?
+    base::string16 state_key = install == SYSTEM_INSTALL ?
         chrome->GetStateMediumKey() : chrome->GetStateKey();
 
     EXPECT_EQ(ERROR_SUCCESS,
               key.Open(root, state_key.c_str(), KEY_QUERY_VALUE));
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValue(google_update::kExperimentLabels, &value));
     EXPECT_EQ(kTestExperimentLabel, value);
     EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels(
         install == SYSTEM_INSTALL, &value));
     EXPECT_EQ(kTestExperimentLabel, value);
     key.Close();
 
     // Now that the label is set, test the delete functionality. An empty label
     // should result in deleting the value.
     EXPECT_TRUE(GoogleUpdateSettings::SetExperimentLabels(
-        install == SYSTEM_INSTALL, string16()));
+        install == SYSTEM_INSTALL, base::string16()));
     EXPECT_EQ(ERROR_SUCCESS,
               key.Open(root, state_key.c_str(), KEY_QUERY_VALUE));
     EXPECT_EQ(ERROR_FILE_NOT_FOUND,
         key.ReadValue(google_update::kExperimentLabels, &value));
     EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels(
         install == SYSTEM_INSTALL, &value));
-    EXPECT_EQ(string16(), value);
+    EXPECT_EQ(base::string16(), value);
     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.
@@ skipping 34 matching lines @@
 
   registry_util::RegistryOverrideManager registry_overrides_;
 };
 
 }  // namespace
 
 // Verify that we return success on no registration (which means stable),
 // whether per-system or per-user install.
 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelAbsent) {
   // Per-system first.
-  string16 channel;
+  base::string16 channel;
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 
   // Then per-user.
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 }
 
 // Test an empty Ap key for system and user.
 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptySystem) {
   SetApField(SYSTEM_INSTALL, L"");
-  string16 channel;
+  base::string16 channel;
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 
   // Per-user lookups still succeed and return empty string.
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 }
 
 TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptyUser) {
   SetApField(USER_INSTALL, L"");
   // Per-system lookups still succeed and return empty string.
-  string16 channel;
+  base::string16 channel;
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 
   // Per-user lookup should succeed.
   EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
                                                                  &channel));
   EXPECT_STREQ(L"", channel.c_str());
 }
 
@@ skipping 401 matching lines @@
   HKEY root_key_;
   bool system_install_;
 };
 
 const wchar_t GetUninstallCommandLine::kDummyCommand[] =
     L"\"goopdate.exe\" /spam";
 
 // Tests that GetUninstallCommandLine returns an empty string if there's no
 // Software\Google\Update key.
 TEST_P(GetUninstallCommandLine, TestNoKey) {
-  EXPECT_EQ(string16(),
+  EXPECT_EQ(base::string16(),
             GoogleUpdateSettings::GetUninstallCommandLine(system_install_));
 }
 
 // Tests that GetUninstallCommandLine returns an empty string if there's no
 // UninstallCmdLine value in the Software\Google\Update key.
 TEST_P(GetUninstallCommandLine, TestNoValue) {
   RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE);
-  EXPECT_EQ(string16(),
+  EXPECT_EQ(base::string16(),
             GoogleUpdateSettings::GetUninstallCommandLine(system_install_));
 }
 
 // Tests that GetUninstallCommandLine returns an empty string if there's an
 // empty UninstallCmdLine value in the Software\Google\Update key.
 TEST_P(GetUninstallCommandLine, TestEmptyValue) {
   RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE)
     .WriteValue(google_update::kRegUninstallCmdLine, L"");
-  EXPECT_EQ(string16(),
+  EXPECT_EQ(base::string16(),
             GoogleUpdateSettings::GetUninstallCommandLine(system_install_));
 }
 
 // Tests that GetUninstallCommandLine returns the correct string if there's an
 // UninstallCmdLine value in the Software\Google\Update key.
 TEST_P(GetUninstallCommandLine, TestRealValue) {
   RegKey(root_key_, google_update::kRegPathGoogleUpdate, KEY_SET_VALUE)
       .WriteValue(google_update::kRegUninstallCmdLine, kDummyCommand);
-  EXPECT_EQ(string16(kDummyCommand),
+  EXPECT_EQ(base::string16(kDummyCommand),
             GoogleUpdateSettings::GetUninstallCommandLine(system_install_));
   // Make sure that there's no value in the other level (user or system).
-  EXPECT_EQ(string16(),
+  EXPECT_EQ(base::string16(),
             GoogleUpdateSettings::GetUninstallCommandLine(!system_install_));
 }
 
 INSTANTIATE_TEST_CASE_P(GetUninstallCommandLineAtLevel, GetUninstallCommandLine,
                         testing::Bool());
 
 // Test GoogleUpdateSettings::GetGoogleUpdateVersion at system- or user-level,
 // according to the param.
 class GetGoogleUpdateVersion : public GoogleUpdateSettingsTest,
                                public testing::WithParamInterface<bool> {
@@ skipping 308 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)));