Replace wstring with string16 in sandbox

sandbox/win/tests/common/controller.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 "sandbox/win/tests/common/controller.h"
 
 #include <string>
 
 #include "base/process/process.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "sandbox/win/src/sandbox_factory.h"
 
 namespace {
 
 static const int kDefaultTimeout = 60000;
 
 // Constructs a full path to a file inside the system32 folder.
-std::wstring MakePathToSys32(const wchar_t* name, bool is_obj_man_path) {
+base::string16 MakePathToSys32(const wchar_t* name, bool is_obj_man_path) {
   wchar_t windows_path[MAX_PATH] = {0};
   if (0 == ::GetSystemWindowsDirectoryW(windows_path, MAX_PATH))
-    return std::wstring();
+    return base::string16();
 
-  std::wstring full_path(windows_path);
+  base::string16 full_path(windows_path);
   if (full_path.empty())
     return full_path;
 
   if (is_obj_man_path)
     full_path.insert(0, L"\\??\\");
 
   full_path += L"\\system32\\";
   full_path += name;
   return full_path;
 }
 
 // Constructs a full path to a file inside the syswow64 folder.
-std::wstring MakePathToSysWow64(const wchar_t* name, bool is_obj_man_path) {
+base::string16 MakePathToSysWow64(const wchar_t* name, bool is_obj_man_path) {
   wchar_t windows_path[MAX_PATH] = {0};
   if (0 == ::GetSystemWindowsDirectoryW(windows_path, MAX_PATH))
-    return std::wstring();
+    return base::string16();
 
-  std::wstring full_path(windows_path);
+  base::string16 full_path(windows_path);
   if (full_path.empty())
     return full_path;
 
   if (is_obj_man_path)
     full_path.insert(0, L"\\??\\");
 
   full_path += L"\\SysWOW64\\";
   full_path += name;
   return full_path;
 }
 
 bool IsProcessRunning(HANDLE process) {
   DWORD exit_code = 0;
   if (::GetExitCodeProcess(process, &exit_code))
     return exit_code == STILL_ACTIVE;
   return false;
 }
 
 }  // namespace
 
 namespace sandbox {
 
-std::wstring MakePathToSys(const wchar_t* name, bool is_obj_man_path) {
+base::string16 MakePathToSys(const wchar_t* name, bool is_obj_man_path) {
   return (base::win::OSInfo::GetInstance()->wow64_status() ==
       base::win::OSInfo::WOW64_ENABLED) ?
       MakePathToSysWow64(name, is_obj_man_path) :
       MakePathToSys32(name, is_obj_man_path);
 }
 
 BrokerServices* GetBroker() {
   static BrokerServices* broker = SandboxFactory::GetBrokerServices();
   static bool is_initialized = false;
 
@@ skipping 67 matching lines @@
     return false;
 
   return (SBOX_ALL_OK == policy_->AddRule(subsystem, semantics, pattern));
 }
 
 bool TestRunner::AddRuleSys32(TargetPolicy::Semantics semantics,
                               const wchar_t* pattern) {
   if (!is_init_)
     return false;
 
-  std::wstring win32_path = MakePathToSys32(pattern, false);
+  base::string16 win32_path = MakePathToSys32(pattern, false);
   if (win32_path.empty())
     return false;
 
   if (!AddRule(TargetPolicy::SUBSYS_FILES, semantics, win32_path.c_str()))
     return false;
 
   if (base::win::OSInfo::GetInstance()->wow64_status() !=
       base::win::OSInfo::WOW64_ENABLED)
     return true;
 
@@ skipping 12 matching lines @@
   return AddRule(TargetPolicy::SUBSYS_FILES, semantics, pattern);
 }
 
 int TestRunner::RunTest(const wchar_t* command) {
   if (MAX_STATE > 10)
     return SBOX_TEST_INVALID_PARAMETER;
 
   wchar_t state_number[2];
   state_number[0] = L'0' + state_;
   state_number[1] = L'\0';
-  std::wstring full_command(state_number);
+  base::string16 full_command(state_number);
   full_command += L" ";
   full_command += command;
 
   return InternalRunTest(full_command.c_str());
 }
 
 int TestRunner::InternalRunTest(const wchar_t* command) {
   if (!is_init_)
     return SBOX_TEST_FAILED_TO_RUN_TEST;
 
   // For simplicity TestRunner supports only one process per instance.
   if (target_process_) {
     if (IsProcessRunning(target_process_))
       return SBOX_TEST_FAILED_TO_RUN_TEST;
     target_process_.Close();
     target_process_id_ = 0;
   }
 
   // Get the path to the sandboxed process.
   wchar_t prog_name[MAX_PATH];
   GetModuleFileNameW(NULL, prog_name, MAX_PATH);
 
   // Launch the sandboxed process.
   ResultCode result = SBOX_ALL_OK;
   PROCESS_INFORMATION target = {0};
 
-  std::wstring arguments(L"\"");
+  base::string16 arguments(L"\"");
   arguments += prog_name;
   arguments += L"\" -child";
   arguments += no_sandbox_ ? L"-no-sandbox " : L" ";
   arguments += command;
 
   if (no_sandbox_) {
     STARTUPINFO startup_info = {sizeof(STARTUPINFO)};
     if (!::CreateProcessW(prog_name, &arguments[0], NULL, NULL, FALSE, 0,
                           NULL, NULL, &startup_info, &target)) {
       return SBOX_ERROR_GENERIC;
@@ skipping 103 matching lines @@
 
     target->LowerToken();
   } else if (0 != _wcsicmp(argv[1], L"-child-no-sandbox")) {
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
   }
 
   return command(argc - 4, argv + 4);
 }
 
 }  // namespace sandbox