Add base:: to string16s in chrome/.

chrome/installer/util/auto_launch_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/auto_launch_util.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
@@ skipping 20 matching lines @@
   FLAG_DISABLE,   // Disable the flag.
   FLAG_ENABLE,    // Enable the flag.
   FLAG_PRESERVE,  // Preserve the value that the flag has currently.
 };
 
 // A helper function that takes a |profile_path| and builds a registry key
 // name to use when deciding where to read/write the auto-launch value
 // to/from. It takes into account the name of the profile (so that different
 // installations of Chrome don't conflict, and so the in the future different
 // profiles can be auto-launched (or not) separately).
-string16 ProfileToKeyName(const string16& profile_directory) {
+base::string16 ProfileToKeyName(const base::string16& profile_directory) {
   base::FilePath path;
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUserDataDir)) {
     path = command_line.GetSwitchValuePath(switches::kUserDataDir);
   } else {
     // Get the path from the same source as the installer, to make sure there
     // are no differences.
     BrowserDistribution* distribution =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     installer::Product product(distribution);
     std::vector<base::FilePath> data_dir_paths;
     product.GetUserDataPaths(&data_dir_paths);
     if (!data_dir_paths.empty())
       path = data_dir_paths[0];
   }
   path = path.Append(profile_directory);
 
   std::string input(path.AsUTF8Unsafe());
   uint8 hash[16];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   std::string hash_string = base::HexEncode(hash, sizeof(hash));
-  return string16(kAutolaunchKeyValue) +
-      ASCIIToWide("_") + ASCIIToWide(hash_string);
+  return base::string16(kAutolaunchKeyValue) + ASCIIToWide("_") +
+         ASCIIToWide(hash_string);
 }
 
 // Returns whether the Chrome executable specified in |application_path| is set
 // to auto-launch at computer startup with a given |command_line_switch|.
 // NOTE: |application_path| is optional and should be blank in most cases (as
 // it will default to the application path of the current executable).
 // |profile_directory| is the name of the directory (leaf, not the full path)
 // that contains the profile that should be opened at computer startup.
 // |command_line_switch| is the switch we are optionally interested in and, if
 // not blank, must be present for the function to return true. If blank, it acts
 // like a wildcard.
 bool WillLaunchAtLoginWithSwitch(const base::FilePath& application_path,
-                                 const string16& profile_directory,
+                                 const base::string16& profile_directory,
                                  const std::string& command_line_switch) {
-  string16 key_name(ProfileToKeyName(profile_directory));
-  string16 autolaunch;
+  base::string16 key_name(ProfileToKeyName(profile_directory));
+  base::string16 autolaunch;
   if (!base::win::ReadCommandFromAutoRun(
       HKEY_CURRENT_USER, key_name, &autolaunch)) {
     return false;
   }
 
   base::FilePath chrome_exe(application_path);
   if (chrome_exe.empty()) {
     if (!PathService::Get(base::DIR_EXE, &chrome_exe)) {
       NOTREACHED();
       return false;
     }
   }
   chrome_exe = chrome_exe.Append(installer::kChromeExe);
 
-  if (autolaunch.find(chrome_exe.value()) == string16::npos)
+  if (autolaunch.find(chrome_exe.value()) == base::string16::npos)
     return false;
 
   return command_line_switch.empty() ||
-         autolaunch.find(ASCIIToUTF16(command_line_switch)) != string16::npos;
+         autolaunch.find(ASCIIToUTF16(command_line_switch)) !=
+             base::string16::npos;
 }
 
-bool AutoStartRequested(const string16& profile_directory,
+bool AutoStartRequested(const base::string16& profile_directory,
                         bool window_requested,
                         const base::FilePath& application_path) {
   if (window_requested) {
     return WillLaunchAtLoginWithSwitch(application_path,
                                        profile_directory,
                                        switches::kAutoLaunchAtStartup);
   } else {
     // Background mode isn't profile specific, but is attached to the Run key
     // for the Default profile.
     return WillLaunchAtLoginWithSwitch(application_path,
                                        ASCIIToUTF16(chrome::kInitialProfile),
                                        switches::kNoStartupWindow);
   }
 }
 
 bool CheckAndRemoveDeprecatedBackgroundModeSwitch() {
   // For backwards compatibility we need to provide a migration path from the
   // previously used key "chromium" that the BackgroundMode used to set, as it
   // is incompatible with the new key (can't have two Run keys with
   // conflicting switches).
-  string16 chromium = ASCIIToUTF16("chromium");
-  string16 value;
+  base::string16 chromium = ASCIIToUTF16("chromium");
+  base::string16 value;
   if (base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER, chromium, &value)) {
     if (value.find(ASCIIToUTF16(switches::kNoStartupWindow)) !=
-        string16::npos) {
+        base::string16::npos) {
       base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, chromium);
       return true;
     }
   }
 
   return false;
 }
 
 void SetWillLaunchAtLogin(const base::FilePath& application_path,
-                          const string16& profile_directory,
+                          const base::string16& profile_directory,
                           FlagSetting foreground_mode,
                           FlagSetting background_mode) {
   if (CheckAndRemoveDeprecatedBackgroundModeSwitch()) {
     // We've found the deprecated switch, we must migrate it (unless background
     // mode is being turned off).
     if (profile_directory == ASCIIToUTF16(chrome::kInitialProfile) &&
         background_mode == FLAG_PRESERVE) {
       // Preserve in this case also covers the deprecated value, so we must
       // explicitly turn the flag on and the rest will be taken care of below.
       background_mode = FLAG_ENABLE;
     } else {
       // When we add support for multiple profiles for foreground mode we need
       // to think about where to store the background mode switch. I think we
       // need to store it with the Default profile (call SetWillLaunchAtLogin
       // again specifying the Default profile), but concerns were raised in
       // review.
       NOTREACHED();
     }
   }
-  string16 key_name(ProfileToKeyName(profile_directory));
+  base::string16 key_name(ProfileToKeyName(profile_directory));
 
   // Check which feature should be enabled.
   bool in_foreground =
       foreground_mode == FLAG_ENABLE ||
       (foreground_mode == FLAG_PRESERVE &&
           WillLaunchAtLoginWithSwitch(application_path,
                                       profile_directory,
                                       switches::kAutoLaunchAtStartup));
   bool in_background =
       background_mode == FLAG_ENABLE ||
       (background_mode == FLAG_PRESERVE &&
           WillLaunchAtLoginWithSwitch(application_path,
                                       profile_directory,
                                       switches::kNoStartupWindow));
 
   // TODO(finnur): Convert this into a shortcut, instead of using the Run key.
   if (in_foreground || in_background) {
     base::FilePath path(application_path);
     if (path.empty()) {
       if (!PathService::Get(base::DIR_EXE, &path)) {
         NOTREACHED();
         return;
       }
     }
-    string16 cmd_line = ASCIIToUTF16("\"");
+    base::string16 cmd_line = ASCIIToUTF16("\"");
     cmd_line += path.value();
     cmd_line += ASCIIToUTF16("\\");
     cmd_line += installer::kChromeExe;
     cmd_line += ASCIIToUTF16("\"");
 
     if (in_background) {
       cmd_line += ASCIIToUTF16(" --");
       cmd_line += ASCIIToUTF16(switches::kNoStartupWindow);
     }
     if (in_foreground) {
@@ skipping 17 matching lines @@
       cmd_line += ASCIIToUTF16("\"");
     }
 
     base::win::AddCommandToAutoRun(
         HKEY_CURRENT_USER, key_name, cmd_line);
   } else {
     base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, key_name);
   }
 }
 
-void DisableAllAutoStartFeatures(const string16& profile_directory) {
+void DisableAllAutoStartFeatures(const base::string16& profile_directory) {
   DisableForegroundStartAtLogin(profile_directory);
   DisableBackgroundStartAtLogin();
 }
 
-void EnableForegroundStartAtLogin(const string16& profile_directory,
+void EnableForegroundStartAtLogin(const base::string16& profile_directory,
                                   const base::FilePath& application_path) {
   SetWillLaunchAtLogin(
       application_path, profile_directory, FLAG_ENABLE, FLAG_PRESERVE);
 }
 
-void DisableForegroundStartAtLogin(const string16& profile_directory) {
+void DisableForegroundStartAtLogin(const base::string16& profile_directory) {
   SetWillLaunchAtLogin(
       base::FilePath(), profile_directory, FLAG_DISABLE, FLAG_PRESERVE);
 }
 
 void EnableBackgroundStartAtLogin() {
   // Background mode isn't profile specific, but we specify the Default profile
   // just to have a unique Run key to attach it to. FilePath is blank because
   // this function is not called from the installer (see comments for
   // EnableAutoStartAtLogin).
   SetWillLaunchAtLogin(base::FilePath(),
                        ASCIIToUTF16(chrome::kInitialProfile),
                        FLAG_PRESERVE,
                        FLAG_ENABLE);
 }
 
 void DisableBackgroundStartAtLogin() {
   SetWillLaunchAtLogin(base::FilePath(),
                        ASCIIToUTF16(chrome::kInitialProfile),
                        FLAG_PRESERVE,
                        FLAG_DISABLE);
 }
 
 }  // namespace auto_launch_util