Replace wstring with string16 in sandbox

sandbox/win/tests/validation_tests/commands.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 <windows.h>
 #include <string>
 
 #include "sandbox/win/tests/validation_tests/commands.h"
 
 #include "sandbox/win/tests/common/controller.h"
 
 namespace {
 
 // Returns the HKEY corresponding to name. If there is no HKEY corresponding
 // to the name it returns NULL.
-HKEY GetHKEYFromString(const std::wstring &name) {
+HKEY GetHKEYFromString(const base::string16 &name) {
   if (L"HKLM" == name)
     return HKEY_LOCAL_MACHINE;
   else if (L"HKCR" == name)
     return HKEY_CLASSES_ROOT;
   else if (L"HKCC" == name)
     return HKEY_CURRENT_CONFIG;
   else if (L"HKCU" == name)
     return HKEY_CURRENT_USER;
   else if (L"HKU" == name)
     return HKEY_USERS;
 
   return NULL;
 }
 
 // Modifies string to remove the leading and trailing quotes.
-void trim_quote(std::wstring* string) {
-  std::wstring::size_type pos1 = string->find_first_not_of(L'"');
-  std::wstring::size_type pos2 = string->find_last_not_of(L'"');
+void trim_quote(base::string16* string) {
+  base::string16::size_type pos1 = string->find_first_not_of(L'"');
+  base::string16::size_type pos2 = string->find_last_not_of(L'"');
 
-  if (std::wstring::npos == pos1 || std::wstring::npos == pos2)
+  if (base::string16::npos == pos1 || base::string16::npos == pos2)
     (*string) = L"";
   else
     (*string) = string->substr(pos1, pos2 + 1);
 }
 
-int TestOpenFile(std::wstring path, bool for_write) {
+int TestOpenFile(base::string16 path, bool for_write) {
   wchar_t path_expanded[MAX_PATH + 1] = {0};
   DWORD size = ::ExpandEnvironmentStrings(path.c_str(), path_expanded,
                                           MAX_PATH);
   if (!size)
     return sandbox::SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   HANDLE file;
   file = ::CreateFile(path_expanded,
                       for_write ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
@@ skipping 82 matching lines @@
   } else {
     ::CloseHandle(thread);
     return SBOX_TEST_SUCCEEDED;
   }
 }
 
 SBOX_TESTS_COMMAND int OpenFile(int argc, wchar_t **argv) {
   if (1 != argc)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
-  std::wstring path = argv[0];
+  base::string16 path = argv[0];
   trim_quote(&path);
 
   return TestOpenReadFile(path);
 }
 
-int TestOpenReadFile(const std::wstring& path) {
+int TestOpenReadFile(const base::string16& path) {
   return TestOpenFile(path, false);
 }
 
 int TestOpenWriteFile(int argc, wchar_t **argv) {
   if (1 != argc)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
-  std::wstring path = argv[0];
+  base::string16 path = argv[0];
   trim_quote(&path);
 
   return TestOpenWriteFile(path);
   }
 
-int TestOpenWriteFile(const std::wstring& path) {
+int TestOpenWriteFile(const base::string16& path) {
   return TestOpenFile(path, true);
 }
 
 SBOX_TESTS_COMMAND int OpenKey(int argc, wchar_t **argv) {
   if (0 == argc || argc > 2)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   // Get the hive.
   HKEY base_key = GetHKEYFromString(argv[0]);
 
   // Get the subkey.
-  std::wstring subkey;
+  base::string16 subkey;
   if (2 == argc) {
     subkey = argv[1];
     trim_quote(&subkey);
   }
 
   return TestOpenKey(base_key, subkey);
 }
 
-int TestOpenKey(HKEY base_key, std::wstring subkey) {
+int TestOpenKey(HKEY base_key, base::string16 subkey) {
   HKEY key;
   LONG err_code = ::RegOpenKeyEx(base_key,
                                  subkey.c_str(),
                                  0,  // Reserved, must be 0.
                                  MAXIMUM_ALLOWED,
                                  &key);
   if (ERROR_SUCCESS == err_code) {
     ::RegCloseKey(key);
     return SBOX_TEST_SUCCEEDED;
   } else if (ERROR_INVALID_HANDLE == err_code ||
@@ skipping 56 matching lines @@
 SBOX_TESTS_COMMAND int SleepCmd(int argc, wchar_t **argv) {
   if (1 != argc)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   ::Sleep(_wtoi(argv[0]));
   return SBOX_TEST_SUCCEEDED;
 }
 
 
 }  // namespace sandbox