Add base:: to string16s in chrome/.

chrome/installer/util/user_experiment.cc

 // Copyright 2013 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/user_experiment.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <wtsapi32.h>
 #include <vector>
@@ skipping 32 matching lines @@
 const wchar_t kToastExpUninstallGroup[] =      L"04";
 const wchar_t kToastExpTriesOkGroup[] =        L"18";
 const wchar_t kToastExpTriesErrorGroup[] =     L"28";
 const wchar_t kToastActiveGroup[] =            L"40";
 const wchar_t kToastUDDirFailure[] =           L"40";
 const wchar_t kToastExpBaseGroup[] =           L"80";
 
 // Substitute the locale parameter in uninstall URL with whatever
 // Google Update tells us is the locale. In case we fail to find
 // the locale, we use US English.
-string16 LocalizeUrl(const wchar_t* url) {
-  string16 language;
+base::string16 LocalizeUrl(const wchar_t* url) {
+  base::string16 language;
   if (!GoogleUpdateSettings::GetLanguage(&language))
     language = L"en-US";  // Default to US English.
   return ReplaceStringPlaceholders(url, language.c_str(), NULL);
 }
 
-string16 GetWelcomeBackUrl() {
+base::string16 GetWelcomeBackUrl() {
   const wchar_t kWelcomeUrl[] = L"http://www.google.com/chrome/intl/$1/"
                                 L"welcomeback-new.html";
   return LocalizeUrl(kWelcomeUrl);
 }
 
 // Converts FILETIME to hours. FILETIME times are absolute times in
 // 100 nanosecond units. For example 5:30 pm of June 15, 2009 is 3580464.
 int FileTimeToHours(const FILETIME& time) {
   const ULONGLONG k100sNanoSecsToHours = 10000000LL * 60 * 60;
   ULARGE_INTEGER uli = {time.dwLowDateTime, time.dwHighDateTime};
@@ skipping 81 matching lines @@
   DWORD len = sizeof(buff);
   PSECURITY_DESCRIPTOR sd = reinterpret_cast<PSECURITY_DESCRIPTOR>(buff);
   if (!::GetFileSecurityW(exe.value().c_str(), DACL_SECURITY_INFORMATION,
                           sd, len, &len)) {
     return false;
   }
   wchar_t* sddl = 0;
   if (!::ConvertSecurityDescriptorToStringSecurityDescriptorW(sd,
       SDDL_REVISION_1, DACL_SECURITY_INFORMATION, &sddl, NULL))
     return false;
-  string16 new_sddl(sddl);
+  base::string16 new_sddl(sddl);
   ::LocalFree(sddl);
   sd = NULL;
   // See MSDN for the  security descriptor definition language (SDDL) syntax,
   // in our case we add "A;" generic read 'GR' and generic execute 'GX' for
   // the nt\authenticated_users 'AU' group, that becomes:
   const wchar_t kAllowACE[] = L"(A;;GRGX;;;AU)";
   // We should check that there are no special ACES for the group we
   // are interested, which is nt\authenticated_users.
-  if (string16::npos != new_sddl.find(L";AU)"))
+  if (base::string16::npos != new_sddl.find(L";AU)"))
     return false;
   // Specific ACEs (not inherited) need to go to the front. It is ok if we
   // are the very first one.
   size_t pos_insert = new_sddl.find(L"(");
-  if (string16::npos == pos_insert)
+  if (base::string16::npos == pos_insert)
     return false;
   // All good, time to change the dacl.
   new_sddl.insert(pos_insert, kAllowACE);
   if (!::ConvertStringSecurityDescriptorToSecurityDescriptorW(new_sddl.c_str(),
       SDDL_REVISION_1, &sd, NULL))
     return false;
   bool rv = ::SetFileSecurityW(exe.value().c_str(), DACL_SECURITY_INFORMATION,
                                sd) == TRUE;
   ::LocalFree(sd);
   return rv;
@@ skipping 50 matching lines @@
   bool launched = base::LaunchProcess(*cmd_line, options, NULL);
   ::CloseHandle(user_token);
   VLOG(1) << __FUNCTION__ << "   result: " << launched;
   return launched;
 }
 
 // A helper function that writes to HKLM if the handle was passed through the
 // command line, but HKCU otherwise. |experiment_group| is the value to write
 // and |last_write| is used when writing to HKLM to determine whether to close
 // the handle when done.
-void SetClient(const string16& experiment_group, bool last_write) {
+void SetClient(const base::string16& experiment_group, bool last_write) {
   static int reg_key_handle = -1;
   if (reg_key_handle == -1) {
     // If a specific Toast Results key handle (presumably to our HKLM key) was
     // passed in to the command line (such as for system level installs), we use
     // it. Otherwise, we write to the key under HKCU.
     const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
     if (cmd_line.HasSwitch(switches::kToastResultsKey)) {
       // Get the handle to the key under HKLM.
       base::StringToInt(
           cmd_line.GetSwitchValueNative(switches::kToastResultsKey),
@@ skipping 65 matching lines @@
       L"DA",          // Experiment is DAxx.
       // One single flavor.
       { { IDS_TRY_TOAST_HEADING3, kToastUiMakeDefault },
         { 0, 0 },
         { 0, 0 },
         { 0, 0 }
       }
     }
   };
 
-  string16 locale;
+  base::string16 locale;
   GoogleUpdateSettings::GetLanguage(&locale);
   if (locale.empty() || (locale == ASCIIToWide("en")))
     locale = ASCIIToWide("en-US");
 
-  string16 brand;
+  base::string16 brand;
   if (!GoogleUpdateSettings::GetBrand(&brand))
     brand = ASCIIToWide("");  // Could still be viable for catch-all rules.
 
   for (int i = 0; i < arraysize(kExperiments); ++i) {
     if (kExperiments[i].locale != locale &&
         kExperiments[i].locale != ASCIIToWide("*"))
       continue;
 
-    std::vector<string16> brand_codes;
+    std::vector<base::string16> brand_codes;
     base::SplitString(kExperiments[i].brands, L',', &brand_codes);
     if (brand_codes.empty())
       return false;
-    for (std::vector<string16>::iterator it = brand_codes.begin();
+    for (std::vector<base::string16>::iterator it = brand_codes.begin();
          it != brand_codes.end(); ++it) {
       if (*it != brand && *it != L"*")
         continue;
       // We have found our match.
       const UserExperimentSpecs& match = kExperiments[i];
       // Find out how many flavors we have. Zero means no experiment.
       int num_flavors = 0;
       while (match.flavors[num_flavors].heading_id) { ++num_flavors; }
       if (!num_flavors)
         return false;
@@ skipping 40 matching lines @@
   }
 
   // The |flavor| value ends up being processed by TryChromeDialogView to show
   // different experiments.
   ExperimentDetails experiment;
   if (!CreateExperimentDetails(-1, &experiment)) {
     VLOG(1) << "Failed to get experiment details.";
     return;
   }
   int flavor = experiment.flavor;
-  string16 base_group = experiment.prefix;
+  base::string16 base_group = experiment.prefix;
 
-  string16 brand;
+  base::string16 brand;
   if (GoogleUpdateSettings::GetBrand(&brand) && (brand == L"CHXX")) {
     // Testing only: the user automatically qualifies for the experiment.
     VLOG(1) << "Experiment qualification bypass";
   } else {
     // Check that the user was not already drafted in this experiment.
-    string16 client;
+    base::string16 client;
     GoogleUpdateSettings::GetClient(&client);
     if (client.size() > 2) {
       if (base_group == client.substr(0, 2)) {
         VLOG(1) << "User already participated in this experiment";
         return;
       }
     }
     // Check browser usage inactivity by the age of the last-write time of the
     // most recently-used chrome user data directory.
     std::vector<base::FilePath> user_data_dirs;
@@ skipping 45 matching lines @@
   cmd_line.AppendSwitchASCII(switches::kInactiveUserToast,
                              base::IntToString(flavor));
   cmd_line.AppendSwitchASCII(switches::kExperimentGroup,
                              WideToASCII(base_group));
   LaunchSetup(&cmd_line, system_level);
 }
 
 // User qualifies for the experiment. To test, use --try-chrome-again=|flavor|
 // as a parameter to chrome.exe.
 void InactiveUserToastExperiment(int flavor,
-                                 const string16& experiment_group,
+                                 const base::string16& experiment_group,
                                  const Product& product,
                                  const base::FilePath& application_path) {
   // Add the 'welcome back' url for chrome to show.
   CommandLine options(CommandLine::NO_PROGRAM);
   options.AppendSwitchNative(::switches::kTryChromeAgain,
       base::IntToString16(flavor));
   // Prepend the url with a space.
-  string16 url(GetWelcomeBackUrl());
+  base::string16 url(GetWelcomeBackUrl());
   options.AppendArg("--");
   options.AppendArgNative(url);
   // The command line should now have the url added as:
   // "chrome.exe -- <url>"
-  DCHECK_NE(string16::npos,
-      options.GetCommandLineString().find(L" -- " + url));
+  DCHECK_NE(base::string16::npos,
+            options.GetCommandLineString().find(L" -- " + url));
 
   // Launch chrome now. It will show the toast UI.
   int32 exit_code = 0;
   if (!product.LaunchChromeAndWait(application_path, options, &exit_code))
     return;
 
   // The chrome process has exited, figure out what happened.
   const wchar_t* outcome = NULL;
   switch (exit_code) {
     case content::RESULT_CODE_NORMAL_EXIT:
@@ skipping 18 matching lines @@
   // running.
   bool system_level_toast = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSystemLevelToast);
 
   CommandLine cmd(InstallUtil::GetChromeUninstallCmd(
                       system_level_toast, product.distribution()->GetType()));
   base::LaunchProcess(cmd, base::LaunchOptions(), NULL);
 }
 
 }  // namespace installer