Add base:: to string16s in chrome/.

chrome/installer/util/installation_validator.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.
 
 // Implementation of the installation validator.
 
 #include "chrome/installer/util/installation_validator.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 151 matching lines @@
   CHROME_APP_HOST_CHROME_FRAME_SINGLE,
   CHROME_APP_HOST_CHROME_FRAME_SINGLE_CHROME_MULTI,
   CHROME_APP_HOST_CHROME_FRAME_MULTI,
   CHROME_APP_HOST_CHROME_FRAME_MULTI_CHROME_MULTI,
   CHROME_APP_HOST_CHROME_MULTI,
 };
 
 void InstallationValidator::ValidateAppCommandFlags(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
-    const std::set<string16>& flags_exp,
-    const string16& name,
+    const std::set<base::string16>& flags_exp,
+    const base::string16& name,
     bool* is_valid) {
   const struct {
-    const string16 exp_key;
+    const base::string16 exp_key;
     bool val;
     const char* msg;
   } check_list[] = {
     {google_update::kRegSendsPingsField,
          app_cmd.sends_pings(),
          "be configured to send pings"},
     {google_update::kRegWebAccessibleField,
          app_cmd.is_web_accessible(),
          "be web accessible"},
     {google_update::kRegAutoRunOnOSUpgradeField,
@@ skipping 19 matching lines @@
 void InstallationValidator::ValidateInstallCommand(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
     const wchar_t* expected_command,
     const wchar_t* expected_app_name,
     const char* expected_switch,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  string16 name(expected_command);
+  base::string16 name(expected_command);
 
   base::FilePath expected_path(
       installer::GetChromeInstallPath(ctx.system_install, ctx.dist)
       .Append(expected_app_name));
 
   if (!base::FilePath::CompareEqualIgnoreCase(expected_path.value(),
                                               cmd_line.GetProgram().value())) {
     *is_valid = false;
     LOG(ERROR) << name << "'s path is not "
                << expected_path.value() << ": "
                << cmd_line.GetProgram().value();
   }
 
   SwitchExpectations expected;
   expected.push_back(std::make_pair(std::string(expected_switch), true));
 
   ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
 
-  std::set<string16> flags_exp;
+  std::set<base::string16> flags_exp;
   flags_exp.insert(google_update::kRegSendsPingsField);
   flags_exp.insert(google_update::kRegWebAccessibleField);
   flags_exp.insert(google_update::kRegRunAsUserField);
   ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
 }
 
 // Validates the "install-application" Google Update product command.
 void InstallationValidator::ValidateInstallAppCommand(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
@@ skipping 14 matching lines @@
 }
 
 // Validates the "on-os-upgrade" Google Update internal command.
 void InstallationValidator::ValidateOnOsUpgradeCommand(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  string16 name(kCmdOnOsUpgrade);
+  base::string16 name(kCmdOnOsUpgrade);
 
   ValidateSetupPath(ctx, cmd_line.GetProgram(), name, is_valid);
 
   SwitchExpectations expected;
   expected.push_back(std::make_pair(std::string(switches::kOnOsUpgrade), true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
   expected.push_back(std::make_pair(std::string(switches::kMultiInstall),
                                     ctx.state.is_multi_install()));
   // Expecting kChrome if and only if kMultiInstall.
   expected.push_back(std::make_pair(std::string(switches::kChrome),
                                     ctx.state.is_multi_install()));
 
   ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
 
-  std::set<string16> flags_exp;
+  std::set<base::string16> flags_exp;
   flags_exp.insert(google_update::kRegAutoRunOnOSUpgradeField);
   ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
 }
 
 // Validates the "query-eula-acceptance" Google Update product command.
 void InstallationValidator::ValidateQueryEULAAcceptanceCommand(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  string16 name(kCmdQueryEULAAcceptance);
+  base::string16 name(kCmdQueryEULAAcceptance);
 
   ValidateSetupPath(ctx, cmd_line.GetProgram(), name, is_valid);
 
   SwitchExpectations expected;
   expected.push_back(std::make_pair(std::string(switches::kQueryEULAAcceptance),
                                     true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
 
   ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
 
-  std::set<string16> flags_exp;
+  std::set<base::string16> flags_exp;
   flags_exp.insert(google_update::kRegWebAccessibleField);
   flags_exp.insert(google_update::kRegRunAsUserField);
   ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
 }
 
 // Validates the "quick-enable-application-host" Google Update product command.
 void InstallationValidator::ValidateQuickEnableApplicationHostCommand(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  string16 name(kCmdQuickEnableApplicationHost);
+  base::string16 name(kCmdQuickEnableApplicationHost);
 
   ValidateSetupPath(ctx, cmd_line.GetProgram(), name, is_valid);
 
   SwitchExpectations expected;
 
   expected.push_back(std::make_pair(
       std::string(switches::kChromeAppLauncher), true));
   expected.push_back(std::make_pair(
       std::string(switches::kSystemLevel), false));
   expected.push_back(std::make_pair(
       std::string(switches::kMultiInstall), true));
   expected.push_back(std::make_pair(
       std::string(switches::kEnsureGoogleUpdatePresent), true));
 
   ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
 
-  std::set<string16> flags_exp;
+  std::set<base::string16> flags_exp;
   flags_exp.insert(google_update::kRegSendsPingsField);
   flags_exp.insert(google_update::kRegWebAccessibleField);
   flags_exp.insert(google_update::kRegRunAsUserField);
   ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
 }
 
 // Validates a product's set of Google Update product commands against a
 // collection of expectations.
 void InstallationValidator::ValidateAppCommandExpectations(
     const ProductContext& ctx,
     const CommandExpectations& expectations,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandExpectations the_expectations(expectations);
 
   AppCommands::CommandMapRange cmd_iterators(
       ctx.state.commands().GetIterators());
   CommandExpectations::iterator expectation;
   for (; cmd_iterators.first != cmd_iterators.second; ++cmd_iterators.first) {
-    const string16& cmd_id = cmd_iterators.first->first;
+    const base::string16& cmd_id = cmd_iterators.first->first;
     // Do we have an expectation for this command?
     expectation = the_expectations.find(cmd_id);
     if (expectation != the_expectations.end()) {
       (expectation->second)(ctx, cmd_iterators.first->second, is_valid);
       // Remove this command from the set of expectations since we found it.
       the_expectations.erase(expectation);
     } else {
       *is_valid = false;
       LOG(ERROR) << ctx.dist->GetDisplayName()
                  << " has an unexpected Google Update product command named \""
@@ skipping 125 matching lines @@
                      binaries_rules);
 
   ValidateBinariesCommands(ctx, is_valid);
 
   ValidateUsageStats(ctx, is_valid);
 }
 
 // Validates the path to |setup_exe| for the product described by |ctx|.
 void InstallationValidator::ValidateSetupPath(const ProductContext& ctx,
                                               const base::FilePath& setup_exe,
-                                              const string16& purpose,
+                                              const base::string16& purpose,
                                               bool* is_valid) {
   DCHECK(is_valid);
 
   BrowserDistribution* bins_dist = ctx.dist;
   if (ctx.state.is_multi_install()) {
     bins_dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES);
   }
 
   base::FilePath expected_path = installer::GetChromeInstallPath(
       ctx.system_install, bins_dist);
   expected_path = expected_path
       .AppendASCII(ctx.state.version().GetString())
       .Append(installer::kInstallerDir)
       .Append(installer::kSetupExe);
   if (!base::FilePath::CompareEqualIgnoreCase(expected_path.value(),
                                               setup_exe.value())) {
     *is_valid = false;
     LOG(ERROR) << ctx.dist->GetDisplayName() << " path to " << purpose
                << " is not " << expected_path.value() << ": "
                << setup_exe.value();
   }
 }
 
 // Validates that |command| meets the expectations described in |expected|.
 void InstallationValidator::ValidateCommandExpectations(
     const ProductContext& ctx,
     const CommandLine& command,
     const SwitchExpectations& expected,
-    const string16& source,
+    const base::string16& source,
     bool* is_valid) {
   for (SwitchExpectations::size_type i = 0, size = expected.size(); i < size;
        ++i) {
     const SwitchExpectations::value_type& expectation = expected[i];
     if (command.HasSwitch(expectation.first) != expectation.second) {
       *is_valid = false;
       LOG(ERROR) << ctx.dist->GetDisplayName() << " " << source
                  << (expectation.second ? " is missing" : " has") << " \""
                  << expectation.first << "\""
                  << (expectation.second ? "" : " but shouldn't") << ": "
                  << command.GetCommandLineString();
     }
   }
 }
 
 // Validates that |command|, originating from |source|, is formed properly for
 // the product described by |ctx|
-void InstallationValidator::ValidateUninstallCommand(const ProductContext& ctx,
-                                                     const CommandLine& command,
-                                                     const string16& source,
-                                                     bool* is_valid) {
+void InstallationValidator::ValidateUninstallCommand(
+    const ProductContext& ctx,
+    const CommandLine& command,
+    const base::string16& source,
+    bool* is_valid) {
   DCHECK(is_valid);
 
   ValidateSetupPath(ctx, command.GetProgram(), ASCIIToUTF16("uninstaller"),
                     is_valid);
 
   const bool is_multi_install = ctx.state.is_multi_install();
   SwitchExpectations expected;
 
   expected.push_back(std::make_pair(std::string(switches::kUninstall), true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
   expected.push_back(std::make_pair(std::string(switches::kMultiInstall),
                                     is_multi_install));
   ctx.rules.AddUninstallSwitchExpectations(ctx, &expected);
 
   ValidateCommandExpectations(ctx, command, expected, source, is_valid);
 }
 
 // Validates the rename command for the product described by |ctx|.
 void InstallationValidator::ValidateRenameCommand(const ProductContext& ctx,
                                                   bool* is_valid) {
   DCHECK(is_valid);
   DCHECK(!ctx.state.rename_cmd().empty());
 
   CommandLine command = CommandLine::FromString(ctx.state.rename_cmd());
-  string16 name(ASCIIToUTF16("in-use renamer"));
+  base::string16 name(ASCIIToUTF16("in-use renamer"));
 
   ValidateSetupPath(ctx, command.GetProgram(), name, is_valid);
 
   SwitchExpectations expected;
 
   expected.push_back(std::make_pair(std::string(switches::kRenameChromeExe),
                                     true));
   expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
                                     ctx.system_install));
   expected.push_back(std::make_pair(std::string(switches::kMultiInstall),
@@ skipping 215 matching lines @@
                                                      InstallationType* type) {
   DCHECK(type);
   InstallationState machine_state;
 
   machine_state.Initialize();
 
   return ValidateInstallationTypeForState(machine_state, system_level, type);
 }
 
 }  // namespace installer