Add base:: to string16s in chrome/.

chrome/installer/util/google_update_settings.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 <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 115 matching lines @@
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   std::wstring reg_path = dist->GetStateKey();
   RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ | KEY_WRITE);
   if (!key.HasValue(name))
     return true;
   return (key.DeleteValue(name) == ERROR_SUCCESS);
 }
 
 bool GetChromeChannelInternal(bool system_install,
                               bool add_multi_modifier,
-                              string16* channel) {
+                              base::string16* channel) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (dist->GetChromeChannel(channel)) {
     return true;
   }
 
   HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  string16 reg_path = dist->GetStateKey();
+  base::string16 reg_path = dist->GetStateKey();
   RegKey key(root_key, reg_path.c_str(), KEY_READ);
 
   installer::ChannelInfo channel_info;
   if (!channel_info.Initialize(key)) {
     channel->assign(installer::kChromeChannelUnknown);
     return false;
   }
 
   if (!channel_info.GetChannelName(channel)) {
     channel->assign(installer::kChromeChannelUnknown);
@@ skipping 243 matching lines @@
                                              did_run ? L"1" : L"0",
                                              system_level);
 }
 
 std::wstring GoogleUpdateSettings::GetChromeChannel(bool system_install) {
   std::wstring channel;
   GetChromeChannelInternal(system_install, false, &channel);
   return channel;
 }
 
-bool GoogleUpdateSettings::GetChromeChannelAndModifiers(bool system_install,
-                                                        string16* channel) {
+bool GoogleUpdateSettings::GetChromeChannelAndModifiers(
+    bool system_install,
+    base::string16* channel) {
   return GetChromeChannelInternal(system_install, true, channel);
 }
 
 void GoogleUpdateSettings::UpdateInstallStatus(bool system_install,
     installer::ArchiveType archive_type, int install_return_code,
     const std::wstring& product_guid) {
   DCHECK(archive_type != installer::UNKNOWN_ARCHIVE_TYPE ||
          install_return_code != 0);
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
@@ skipping 144 matching lines @@
     }
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   if (is_overridden != NULL)
     *is_overridden = found_override;
 
   return update_policy;
 }
 
-string16 GoogleUpdateSettings::GetUninstallCommandLine(bool system_install) {
+base::string16 GoogleUpdateSettings::GetUninstallCommandLine(
+    bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  string16 cmd_line;
+  base::string16 cmd_line;
   RegKey update_key;
 
   if (update_key.Open(root_key, google_update::kRegPathGoogleUpdate,
                       KEY_QUERY_VALUE) == ERROR_SUCCESS) {
     update_key.ReadValue(google_update::kRegUninstallCmdLine, &cmd_line);
   }
 
   return cmd_line;
 }
 
 Version GoogleUpdateSettings::GetGoogleUpdateVersion(bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  string16 version;
+  base::string16 version;
   RegKey key;
 
   if (key.Open(root_key,
                google_update::kRegPathGoogleUpdate,
                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
       key.ReadValue(google_update::kRegGoogleUpdateVersion,
                     &version) == ERROR_SUCCESS) {
     return Version(UTF16ToUTF8(version));
   }
 
@@ skipping 36 matching lines @@
 
 bool GoogleUpdateSettings::GetUpdateDetailForApp(bool system_install,
                                                  const wchar_t* app_guid,
                                                  ProductData* data) {
   DCHECK(app_guid);
   DCHECK(data);
 
   bool product_found = false;
 
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-  string16 clientstate_reg_path(google_update::kRegPathClientState);
+  base::string16 clientstate_reg_path(google_update::kRegPathClientState);
   clientstate_reg_path.append(L"\\");
   clientstate_reg_path.append(app_guid);
 
   RegKey clientstate;
   if (clientstate.Open(root_key, clientstate_reg_path.c_str(),
                        KEY_QUERY_VALUE) == ERROR_SUCCESS) {
-    string16 version;
+    base::string16 version;
     DWORD dword_value;
     if ((clientstate.ReadValueDW(google_update::kRegLastCheckSuccessField,
                                  &dword_value) == ERROR_SUCCESS) &&
         (clientstate.ReadValue(google_update::kRegVersionField,
                                &version) == ERROR_SUCCESS)) {
       product_found = true;
       data->version = WideToASCII(version);
       data->last_success = base::Time::FromTimeT(dword_value);
       data->last_result = 0;
       data->last_error_code = 0;
@@ skipping 30 matching lines @@
 bool GoogleUpdateSettings::GetUpdateDetail(bool system_install,
                                            ProductData* data) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   return GetUpdateDetailForApp(system_install,
                                dist->GetAppGuid().c_str(),
                                data);
 }
 
 bool GoogleUpdateSettings::SetExperimentLabels(
     bool system_install,
-    const string16& experiment_labels) {
+    const base::string16& experiment_labels) {
   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   // Use the browser distribution and install level to write to the correct
   // client state/app guid key.
   bool success = false;
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (dist->ShouldSetExperimentLabels()) {
-    string16 client_state_path(
+    base::string16 client_state_path(
         system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
     RegKey client_state(
         reg_root, client_state_path.c_str(), KEY_SET_VALUE);
     if (experiment_labels.empty()) {
       success = client_state.DeleteValue(google_update::kExperimentLabels)
           == ERROR_SUCCESS;
     } else {
       success = client_state.WriteValue(google_update::kExperimentLabels,
           experiment_labels.c_str()) == ERROR_SUCCESS;
     }
   }
 
   return success;
 }
 
 bool GoogleUpdateSettings::ReadExperimentLabels(
     bool system_install,
-    string16* experiment_labels) {
+    base::string16* experiment_labels) {
   HKEY reg_root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   // If this distribution does not set the experiment labels, don't bother
   // reading.
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!dist->ShouldSetExperimentLabels())
     return false;
 
-  string16 client_state_path(
+  base::string16 client_state_path(
       system_install ? dist->GetStateMediumKey() : dist->GetStateKey());
 
   RegKey client_state;
   LONG result =
       client_state.Open(reg_root, client_state_path.c_str(), KEY_QUERY_VALUE);
   if (result == ERROR_SUCCESS) {
     result = client_state.ReadValue(google_update::kExperimentLabels,
                                     experiment_labels);
   }
 
   // If the key or value was not present, return the empty string.
   if (result == ERROR_FILE_NOT_FOUND || result == ERROR_PATH_NOT_FOUND) {
     experiment_labels->clear();
     return true;
   }
 
   return result == ERROR_SUCCESS;
 }