Add base:: to string16s in chrome/.

chrome/installer/util/google_update_util.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_util.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 32 matching lines @@
 }
 
 // Returns GoogleUpdateSetup.exe's executable path at specified level.
 // or an empty path if none is found.
 base::FilePath GetGoogleUpdateSetupExe(bool system_install) {
   const HKEY root_key = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey update_key;
 
   if (update_key.Open(root_key, kRegPathGoogleUpdate, KEY_QUERY_VALUE) ==
           ERROR_SUCCESS) {
-    string16 path_str;
-    string16 version_str;
+    base::string16 path_str;
+    base::string16 version_str;
     if ((update_key.ReadValue(kRegPathField, &path_str) == ERROR_SUCCESS) &&
         (update_key.ReadValue(kRegGoogleUpdateVersion, &version_str) ==
              ERROR_SUCCESS)) {
       return base::FilePath(path_str).DirName().Append(version_str).
           Append(kGoogleUpdateSetupExe);
     }
   }
   return base::FilePath();
 }
 
 // If Google Update is present at system-level, sets |cmd_string| to the command
 // line to install Google Update at user-level and returns true.
 // Otherwise, clears |cmd_string| and returns false.
-bool GetUserLevelGoogleUpdateInstallCommandLine(string16* cmd_string) {
+bool GetUserLevelGoogleUpdateInstallCommandLine(base::string16* cmd_string) {
   cmd_string->clear();
   base::FilePath google_update_setup(
       GetGoogleUpdateSetupExe(true));  // system-level.
   if (!google_update_setup.empty()) {
     CommandLine cmd(google_update_setup);
     // Appends "/install runtime=true&needsadmin=false /silent /nomitag".
     // NB: /nomitag needs to be at the end.
     // Constants are found in code.google.com/p/omaha/common/const_cmd_line.h.
     cmd.AppendArg("/install");
     // The "&" can be used in base::LaunchProcess() without quotation
     // (this is problematic only if run from command prompt).
     cmd.AppendArg("runtime=true&needsadmin=false");
     cmd.AppendArg("/silent");
     cmd.AppendArg("/nomitag");
     *cmd_string = cmd.GetCommandLineString();
   }
   return !cmd_string->empty();
 }
 
 // Launches command |cmd_string|, and waits for |timeout| milliseconds before
 // timing out.  To wait indefinitely, one can set
 // |timeout| to be base::TimeDelta::FromMilliseconds(INFINITE).
 // Returns true if this executes successfully.
 // Returns false if command execution fails to execute, or times out.
-bool LaunchProcessAndWaitWithTimeout(const string16& cmd_string,
+bool LaunchProcessAndWaitWithTimeout(const base::string16& cmd_string,
                                      base::TimeDelta timeout) {
   bool success = false;
   base::win::ScopedHandle process;
   int exit_code = 0;
   VLOG(0) << "Launching: " << cmd_string;
   if (!base::LaunchProcess(cmd_string, base::LaunchOptions(),
                            &process)) {
     PLOG(ERROR) << "Failed to launch (" << cmd_string << ")";
   } else if (!base::WaitForExitCodeWithTimeout(process, &exit_code, timeout)) {
     // The GetExitCodeProcess failed or timed-out.
@@ skipping 69 matching lines @@
 
 }  // namespace
 
 bool EnsureUserLevelGoogleUpdatePresent() {
   VLOG(0) << "Ensuring Google Update is present at user-level.";
 
   bool success = false;
   if (IsGoogleUpdatePresent(false)) {
     success = true;
   } else {
-    string16 cmd_string;
+    base::string16 cmd_string;
     if (!GetUserLevelGoogleUpdateInstallCommandLine(&cmd_string)) {
       LOG(ERROR) << "Cannot find Google Update at system-level.";
       // Ideally we should return false. However, this case should not be
       // encountered by regular users, and developers (who often installs
       // Chrome without Google Update) may be unduly impeded by this case.
       // Therefore we return true.
       success = true;
     } else {
       success = LaunchProcessAndWaitWithTimeout(cmd_string,
           base::TimeDelta::FromMilliseconds(INFINITE));
     }
   }
   return success;
 }
 
 bool UninstallGoogleUpdate(bool system_install) {
   bool success = false;
-  string16 cmd_string(
+  base::string16 cmd_string(
       GoogleUpdateSettings::GetUninstallCommandLine(system_install));
   if (cmd_string.empty()) {
     success = true;  // Nothing to; vacuous success.
   } else {
     success = LaunchProcessAndWaitWithTimeout(cmd_string,
         base::TimeDelta::FromMilliseconds(kGoogleUpdateTimeoutMs));
   }
   return success;
 }
 
 std::string GetUntrustedDataValue(const std::string& key) {
   std::map<std::string, std::string> untrusted_data;
   if (GetGoogleUpdateUntrustedData(&untrusted_data)) {
     std::map<std::string, std::string>::const_iterator data_it(
         untrusted_data.find(key));
     if (data_it != untrusted_data.end())
       return data_it->second;
   }
 
   return std::string();
 }
 
 }  // namespace google_update