Use base namespace for string16 in components and cloud_print.

cloud_print/service/win/cloud_print_service.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 <atlbase.h>
 #include <security.h>
 
 #include <iomanip>
 #include <iostream>
 #include <iterator>
@@ skipping 62 matching lines @@
 
   for (size_t i = 0; i < arraysize(kSwitchHelp); ++i) {
     std::cout << std::setiosflags(std::ios::left);
     std::cout << "  -" << std::setw(16) << kSwitchHelp[i].name;
     std::cout << cloud_print::LoadLocalString(kSwitchHelp[i].description);
     std::cout << "\n";
   }
   std::cout << "\n";
 }
 
-string16 GetOption(int string_id, const string16& default,
+base::string16 GetOption(int string_id, const base::string16& default,
                    bool secure) {
-  string16 prompt_format = cloud_print::LoadLocalString(string_id) ;
-  std::vector<string16> substitutions(1, default);
+  base::string16 prompt_format = cloud_print::LoadLocalString(string_id) ;

[Scott Byer, 2013/12/06 17:28:06]

nit: extra space before semicolon.

+  std::vector<base::string16> substitutions(1, default);
   std::cout << ReplaceStringPlaceholders(prompt_format, substitutions, NULL);
-  string16 tmp;
+  base::string16 tmp;
   if (secure) {
     DWORD saved_mode = 0;
     // Don't close.
     HANDLE stdin_handle = ::GetStdHandle(STD_INPUT_HANDLE);
     ::GetConsoleMode(stdin_handle, &saved_mode);
     ::SetConsoleMode(stdin_handle, saved_mode & ~ENABLE_ECHO_INPUT);
     std::getline(std::wcin, tmp);
     ::SetConsoleMode(stdin_handle, saved_mode);
     std::cout << "\n";
   } else {
     std::getline(std::wcin, tmp);
   }
   if (tmp.empty())
     return default;
   return tmp;
 }
 
 HRESULT ReportError(HRESULT hr, int string_id) {
   LOG(ERROR) << cloud_print::GetErrorMessage(hr);
   std::cerr << cloud_print::LoadLocalString(string_id);
   std::cerr << "\n";
   return hr;
 }
 
-string16 StateAsString(ServiceController::State state) {
+base::string16 StateAsString(ServiceController::State state) {
   DWORD string_id = 0;
   switch(state) {
   case ServiceController::STATE_NOT_FOUND:
     string_id = IDS_SERVICE_NOT_FOUND;
     break;
   case ServiceController::STATE_STOPPED:
     string_id = IDS_SERVICE_STOPPED;
     break;
   case ServiceController::STATE_RUNNING:
     string_id = IDS_SERVICE_RUNNING;
     break;
   }
-  return string_id ? cloud_print::LoadLocalString(string_id) : string16();
+  return string_id ? cloud_print::LoadLocalString(string_id) : base::string16();
 }
 
 }  // namespace
 
 
 class CloudPrintServiceModule
     : public ATL::CAtlServiceModuleT<CloudPrintServiceModule,
                                      IDS_SERVICE_NAME> {
  public:
   typedef ATL::CAtlServiceModuleT<CloudPrintServiceModule,
@@ skipping 70 matching lines @@
     if (!user_data_dir_switch_.empty())
       user_data_dir_switch_ = base::MakeAbsoluteFilePath(user_data_dir_switch_);
 
     if (command_line.HasSwitch(kStopSwitch))
       return controller_->StopService();
 
     if (command_line.HasSwitch(kUninstallSwitch))
       return controller_->UninstallService();
 
     if (command_line.HasSwitch(kInstallSwitch)) {
-      string16 run_as_user;
-      string16 run_as_password;
+      base::string16 run_as_user;
+      base::string16 run_as_password;
       base::FilePath user_data_dir;
       std::vector<std::string> printers;
       HRESULT hr = SelectWindowsAccount(&run_as_user, &run_as_password,
                                         &user_data_dir, &printers);
       if (FAILED(hr))
         return hr;
 
       DCHECK(user_data_dir_switch_.empty() ||
              user_data_dir_switch_ == user_data_dir);
 
@@ skipping 26 matching lines @@
       *is_service = true;
       check_requirements_ = command_line.HasSwitch(kRequirementsSwitch);
       return S_OK;
     }
 
 
     InvalidUsage();
     return S_FALSE;
   }
 
-  HRESULT SelectWindowsAccount(string16* run_as_user, string16* run_as_password,
+  HRESULT SelectWindowsAccount(base::string16* run_as_user,
+                               base::string16* run_as_password,
                                base::FilePath* user_data_dir,
                                std::vector<std::string>* printers) {
     *run_as_user = GetCurrentUserName();
     std::cout << cloud_print::LoadLocalString(IDS_WINDOWS_USER_PROMPT1) << "\n";
     *run_as_user = GetOption(IDS_WINDOWS_USER_PROMPT2, *run_as_user, false);
     *run_as_user = ReplaceLocalHostInName(*run_as_user);
     *run_as_password = GetOption(IDS_WINDOWS_PASSWORD_PROMPT, L"", true);
     SetupListener setup(*run_as_user);
     HRESULT hr = controller_->InstallCheckService(*run_as_user,
                                                   *run_as_password,
@@ skipping 56 matching lines @@
 
     std::string contents;
     ServiceState service_state;
 
     bool is_valid = base::ReadFileToString(file, &contents) &&
                     service_state.FromString(contents);
     std::string proxy_id = service_state.proxy_id();
 
     LOG(INFO) << file.value() << ": " << contents;
 
-    string16 message =
+    base::string16 message =
         cloud_print::LoadLocalString(IDS_ADD_PRINTERS_USING_CHROME);
     std::cout << "\n" << message.c_str() << "\n" ;
     std::string new_contents =
         ChromeLauncher::CreateServiceStateFile(proxy_id, printers);
 
     if (new_contents.empty()) {
       return ReportError(E_FAIL, IDS_ERROR_FAILED_CREATE_CONFIG);
     }
 
     if (new_contents != contents) {
@@ skipping 56 matching lines @@
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
   logging::InitLogging(settings);
 
   logging::SetMinLogLevel(
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableLogging) ?
       logging::LOG_INFO : logging::LOG_FATAL);
 
   return _AtlModule.WinMain(0);
 }