Add base:: to string16s in chrome/.

chrome/app/client_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 <windows.h>
 #include <shlwapi.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
@@ skipping 96 matching lines @@
   COMPILE_ASSERT(kDefaultPercentage % 5 == 0, default_percentage_not_mult_5);
 
   // Roll the dice to determine if this user is in the experiment and if so,
   // in which experimental group.
   double population = 0.0;
   double group = 0.0;
   GetPreReadPopulationAndGroup(&population, &group);
 
   // We limit experiment populations to 1% of the Stable and 10% of each of
   // the other channels.
-  const string16 channel(GoogleUpdateSettings::GetChromeChannel(
+  const base::string16 channel(GoogleUpdateSettings::GetChromeChannel(
       GoogleUpdateSettings::IsSystemInstall()));
   double threshold = (channel == installer::kChromeChannelStable) ? 0.01 : 0.10;
 
   // If the experiment has expired use the default pre-read level. Otherwise,
   // those not in the experiment population also use the default pre-read level.
   size_t value = kDefaultPercentage;
   const char* format_str = kDefaultFormatStr;
   if (PreReadExperimentIsActive() && (population <= threshold)) {
     // We divide the experiment population into groups pre-reading at 5 percent
     // increments in the range [0, 100].
@@ skipping 13 matching lines @@
   scoped_ptr<base::Environment> env(base::Environment::Create());
   env->SetVar(chrome::kPreReadEnvironmentVariable, group_name);
 
   // Return the percentage value to be used.
   return value;
 }
 
 // Expects that |dir| has a trailing backslash. |dir| is modified so it
 // contains the full path that was tried. Caller must check for the return
 // value not being null to determine if this path contains a valid dll.
-HMODULE LoadChromeWithDirectory(string16* dir) {
+HMODULE LoadChromeWithDirectory(base::string16* dir) {
   ::SetCurrentDirectoryW(dir->c_str());
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
 #if !defined(CHROME_MULTIPLE_DLL)
   const wchar_t* dll_name = installer::kChromeDll;
 #else
   const wchar_t* dll_name =
       cmd_line.HasSwitch(switches::kProcessType) &&
               cmd_line.GetSwitchValueASCII(switches::kProcessType) != "service"
           ? installer::kChromeChildDll
           : installer::kChromeDll;
 #endif
   dir->append(dll_name);
 
 #if !defined(WIN_DISABLE_PREREAD)
   // We pre-read the binary to warm the memory caches (fewer hard faults to
   // page parts of the binary in).
   if (!cmd_line.HasSwitch(switches::kProcessType)) {
     const size_t kStepSize = 1024 * 1024;
     size_t percentage = InitPreReadPercentage();
     ImagePreReader::PartialPreReadImage(dir->c_str(), percentage, kStepSize);
   }
 #endif
 
   return ::LoadLibraryExW(dir->c_str(), NULL,
                           LOAD_WITH_ALTERED_SEARCH_PATH);
 }
 
-void RecordDidRun(const string16& dll_path) {
+void RecordDidRun(const base::string16& dll_path) {
   bool system_level = !InstallUtil::IsPerUserInstall(dll_path.c_str());
   GoogleUpdateSettings::UpdateDidRunState(true, system_level);
 }
 
-void ClearDidRun(const string16& dll_path) {
+void ClearDidRun(const base::string16& dll_path) {
   bool system_level = !InstallUtil::IsPerUserInstall(dll_path.c_str());
   GoogleUpdateSettings::UpdateDidRunState(false, system_level);
 }
 
 }  // namespace
 
-string16 GetExecutablePath() {
+base::string16 GetExecutablePath() {
   wchar_t path[MAX_PATH];
   ::GetModuleFileNameW(NULL, path, MAX_PATH);
   if (!::PathRemoveFileSpecW(path))
-    return string16();
-  string16 exe_path(path);
+    return base::string16();
+  base::string16 exe_path(path);
   return exe_path.append(1, L'\\');
 }
 
-string16 GetCurrentModuleVersion() {
+base::string16 GetCurrentModuleVersion() {
   scoped_ptr<FileVersionInfo> file_version_info(
       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
   if (file_version_info.get()) {
-    string16 version_string(file_version_info->file_version());
+    base::string16 version_string(file_version_info->file_version());
     if (Version(WideToASCII(version_string)).IsValid())
       return version_string;
   }
-  return string16();
+  return base::string16();
 }
 
 //=============================================================================
 
 MainDllLoader::MainDllLoader() : dll_(NULL) {
 }
 
 MainDllLoader::~MainDllLoader() {
 }
 
 // Loading chrome is an interesting affair. First we try loading from the
 // current directory to support run-what-you-compile and other development
 // scenarios.
 // If that fails then we look at the --chrome-version command line flag to
 // determine if we should stick with an older dll version even if a new one is
 // available to support upgrade-in-place scenarios.
 // If that fails then finally we look at the version resource in the current
 // module. This is the expected path for chrome.exe browser instances in an
 // installed build.
-HMODULE MainDllLoader::Load(string16* out_version, string16* out_file) {
+HMODULE MainDllLoader::Load(base::string16* out_version,
+                            base::string16* out_file) {
   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
-  const string16 dir(GetExecutablePath());
+  const base::string16 dir(GetExecutablePath());
   *out_file = dir;
   HMODULE dll = LoadChromeWithDirectory(out_file);
   if (!dll) {
     // Loading from same directory (for developers) failed.
-    string16 version_string;
+    base::string16 version_string;
     if (cmd_line.HasSwitch(switches::kChromeVersion)) {
       // This is used to support Chrome Frame, see http://crbug.com/88589.
       version_string = cmd_line.GetSwitchValueNative(switches::kChromeVersion);
 
       if (!Version(WideToASCII(version_string)).IsValid()) {
         // If a bogus command line flag was given, then abort.
         LOG(ERROR) << "Invalid command line version: " << version_string;
         return NULL;
       }
     }
@@ skipping 21 matching lines @@
   DCHECK(dll);
 
   return dll;
 }
 
 // Launching is a matter of loading the right dll, setting the CHROME_VERSION
 // environment variable and just calling the entry point. Derived classes can
 // add custom code in the OnBeforeLaunch callback.
 int MainDllLoader::Launch(HINSTANCE instance,
                           sandbox::SandboxInterfaceInfo* sbox_info) {
-  string16 version;
-  string16 file;
+  base::string16 version;
+  base::string16 file;
   dll_ = Load(&version, &file);
   if (!dll_)
     return chrome::RESULT_CODE_MISSING_DATA;
 
   scoped_ptr<base::Environment> env(base::Environment::Create());
   env->SetVar(chrome::kChromeVersionEnvVar, WideToUTF8(version));
   // TODO(erikwright): Remove this when http://crbug.com/174953 is fixed and
   // widely deployed.
   env->UnSetVar(env_vars::kGoogleUpdateIsMachineEnvVar);
 
@@ skipping 22 matching lines @@
                << "RelaunchChromeBrowserWithNewCommandLineIfNeeded";
   } else {
     relaunch_function();
   }
 }
 
 //=============================================================================
 
 class ChromeDllLoader : public MainDllLoader {
  public:
-  virtual string16 GetRegistryPath() {
-    string16 key(google_update::kRegPathClients);
+  virtual base::string16 GetRegistryPath() {
+    base::string16 key(google_update::kRegPathClients);
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     key.append(L"\\").append(dist->GetAppGuid());
     return key;
   }
 
-  virtual void OnBeforeLaunch(const string16& dll_path) {
+  virtual void OnBeforeLaunch(const base::string16& dll_path) {
     RecordDidRun(dll_path);
   }
 
-  virtual int OnBeforeExit(int return_code, const string16& dll_path) {
+  virtual int OnBeforeExit(int return_code, const base::string16& dll_path) {
     // NORMAL_EXIT_CANCEL is used for experiments when the user cancels
     // so we need to reset the did_run signal so omaha does not count
     // this run as active usage.
     if (chrome::RESULT_CODE_NORMAL_EXIT_CANCEL == return_code) {
       ClearDidRun(dll_path);
     }
     return return_code;
   }
 };
 
 //=============================================================================
 
 class ChromiumDllLoader : public MainDllLoader {
  public:
-  virtual string16 GetRegistryPath() {
+  virtual base::string16 GetRegistryPath() {
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     return dist->GetVersionKey();
   }
 };
 
 MainDllLoader* MakeMainDllLoader() {
 #if defined(GOOGLE_CHROME_BUILD)
   return new ChromeDllLoader();
 #else
   return new ChromiumDllLoader();
 #endif
 }