Replace wstring with string16 in sandbox

sandbox/win/src/file_policy_test.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <cctype>
 
 #include <windows.h>
 #include <winioctl.h>
 
@@ skipping 44 matching lines @@
       return SBOX_TEST_SUCCEEDED;
     return SBOX_TEST_DENIED;
   }
 }
 
 SBOX_TESTS_COMMAND int File_Win32Create(int argc, wchar_t **argv) {
   if (argc != 1) {
     SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
   }
 
-  std::wstring full_path = MakePathToSys(argv[0], false);
+  base::string16 full_path = MakePathToSys(argv[0], false);
   if (full_path.empty()) {
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
   }
 
   HANDLE file = ::CreateFileW(full_path.c_str(), GENERIC_READ, kSharing,
                               NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 
   if (INVALID_HANDLE_VALUE != file) {
     ::CloseHandle(file);
     return SBOX_TEST_SUCCEEDED;
@@ skipping 11 matching lines @@
 // call succeeded or not.
 SBOX_TESTS_COMMAND int File_CreateSys32(int argc, wchar_t **argv) {
   BINDNTDLL(NtCreateFile);
   BINDNTDLL(RtlInitUnicodeString);
   if (!NtCreateFile || !RtlInitUnicodeString)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   if (argc != 1)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
-  std::wstring file(argv[0]);
+  base::string16 file(argv[0]);
   if (0 != _wcsnicmp(file.c_str(), kNTObjManPrefix, kNTObjManPrefixLen))
     file = MakePathToSys(argv[0], true);
 
   UNICODE_STRING object_name;
   RtlInitUnicodeString(&object_name, file.c_str());
 
   OBJECT_ATTRIBUTES obj_attributes = {0};
   InitializeObjectAttributes(&obj_attributes, &object_name,
                              OBJ_CASE_INSENSITIVE, NULL, NULL);
 
@@ skipping 17 matching lines @@
 // call succeeded or not.
 SBOX_TESTS_COMMAND int File_OpenSys32(int argc, wchar_t **argv) {
   BINDNTDLL(NtOpenFile);
   BINDNTDLL(RtlInitUnicodeString);
   if (!NtOpenFile || !RtlInitUnicodeString)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   if (argc != 1)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
-  std::wstring file = MakePathToSys(argv[0], true);
+  base::string16 file = MakePathToSys(argv[0], true);
   UNICODE_STRING object_name;
   RtlInitUnicodeString(&object_name, file.c_str());
 
   OBJECT_ATTRIBUTES obj_attributes = {0};
   InitializeObjectAttributes(&obj_attributes, &object_name,
                              OBJ_CASE_INSENSITIVE, NULL, NULL);
 
   HANDLE handle;
   IO_STATUS_BLOCK io_block = {0};
   NTSTATUS status = NtOpenFile(&handle, FILE_READ_DATA, &obj_attributes,
                                &io_block, kSharing, 0);
   if (NT_SUCCESS(status)) {
     ::CloseHandle(handle);
     return SBOX_TEST_SUCCEEDED;
   } else if (STATUS_ACCESS_DENIED == status) {
     return SBOX_TEST_DENIED;
   } else if (STATUS_OBJECT_NAME_NOT_FOUND == status) {
     return SBOX_TEST_NOT_FOUND;
   }
   return SBOX_TEST_FAILED;
 }
 
 SBOX_TESTS_COMMAND int File_GetDiskSpace(int argc, wchar_t **argv) {
-  std::wstring sys_path = MakePathToSys(L"", false);
+  base::string16 sys_path = MakePathToSys(L"", false);
   if (sys_path.empty()) {
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
   }
   ULARGE_INTEGER free_user = {0};
   ULARGE_INTEGER total = {0};
   ULARGE_INTEGER free_total = {0};
   if (::GetDiskFreeSpaceExW(sys_path.c_str(), &free_user, &total,
                             &free_total)) {
     if ((total.QuadPart != 0) && (free_total.QuadPart !=0)) {
       return SBOX_TEST_SUCCEEDED;
@@ skipping 35 matching lines @@
   if (!NtQueryAttributesFile || !NtQueryFullAttributesFile ||
       !RtlInitUnicodeString)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   if (argc != 2)
     return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND;
 
   bool expect_directory = (L'd' == argv[1][0]);
 
   UNICODE_STRING object_name;
-  std::wstring file = MakePathToSys(argv[0], true);
+  base::string16 file = MakePathToSys(argv[0], true);
   RtlInitUnicodeString(&object_name, file.c_str());
 
   OBJECT_ATTRIBUTES obj_attributes = {0};
   InitializeObjectAttributes(&obj_attributes, &object_name,
                              OBJ_CASE_INSENSITIVE, NULL, NULL);
 
   FILE_BASIC_INFORMATION info = {0};
   FILE_NETWORK_OPEN_INFORMATION full_info = {0};
   NTSTATUS status1 = NtQueryAttributesFile(&obj_attributes, &info);
   NTSTATUS status2 = NtQueryFullAttributesFile(&obj_attributes, &full_info);
@@ skipping 32 matching lines @@
   TestRunner runner;
   EXPECT_TRUE(runner.AddRuleSys32(TargetPolicy::FILES_ALLOW_ANY, L"calc.exe"));
 
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"File_CreateSys32 calc.exe"));
 
   runner.SetTestState(BEFORE_REVERT);
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"File_CreateSys32 calc.exe"));
 }
 
 TEST(FilePolicyTest, AllowNtCreateWithNativePath) {
-  std::wstring calc = MakePathToSys(L"calc.exe", false);
-  std::wstring nt_path;
+  base::string16 calc = MakePathToSys(L"calc.exe", false);
+  base::string16 nt_path;
   ASSERT_TRUE(GetNtPathFromWin32Path(calc, &nt_path));
   TestRunner runner;
   runner.AddFsRule(TargetPolicy::FILES_ALLOW_READONLY, nt_path.c_str());
 
   wchar_t buff[MAX_PATH];
   ::wsprintfW(buff, L"File_CreateSys32 %s", nt_path.c_str());
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(buff));
 
   std::transform(nt_path.begin(), nt_path.end(), nt_path.begin(), std::tolower);
   ::wsprintfW(buff, L"File_CreateSys32 %s", nt_path.c_str());
@@ skipping 246 matching lines @@
   wchar_t temp_directory[MAX_PATH];
   wchar_t temp_file_name[MAX_PATH];
   ASSERT_NE(::GetTempPath(MAX_PATH, temp_directory), 0u);
   ASSERT_NE(::GetTempFileName(temp_directory, L"test", 0, temp_file_name), 0u);
 
   // Delete the file and create a directory instead.
   ASSERT_TRUE(::DeleteFile(temp_file_name));
   ASSERT_TRUE(::CreateDirectory(temp_file_name, NULL));
 
   // Create a temporary file in the subfolder.
-  std::wstring subfolder = temp_file_name;
-  std::wstring temp_file_title = subfolder.substr(subfolder.rfind(L"\\") + 1);
-  std::wstring temp_file = subfolder + L"\\file_" + temp_file_title;
+  base::string16 subfolder = temp_file_name;
+  base::string16 temp_file_title = subfolder.substr(subfolder.rfind(L"\\") + 1);
+  base::string16 temp_file = subfolder + L"\\file_" + temp_file_title;
 
   HANDLE file = ::CreateFile(temp_file.c_str(), FILE_ALL_ACCESS,
                              FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                              CREATE_ALWAYS, 0, NULL);
   ASSERT_TRUE(INVALID_HANDLE_VALUE != file);
   ASSERT_TRUE(::CloseHandle(file));
 
   // Create a temporary file in the temp directory.
-  std::wstring temp_dir = temp_directory;
-  std::wstring temp_file_in_temp = temp_dir + L"file_" + temp_file_title;
+  base::string16 temp_dir = temp_directory;
+  base::string16 temp_file_in_temp = temp_dir + L"file_" + temp_file_title;
   file = ::CreateFile(temp_file_in_temp.c_str(), FILE_ALL_ACCESS,
                       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                       CREATE_ALWAYS, 0, NULL);
   ASSERT_TRUE(file != NULL);
   ASSERT_TRUE(::CloseHandle(file));
 
   // Give write access to the temp directory.
-  std::wstring temp_dir_wildcard = temp_dir + L"*";
+  base::string16 temp_dir_wildcard = temp_dir + L"*";
   EXPECT_TRUE(runner.AddFsRule(TargetPolicy::FILES_ALLOW_ANY,
                                temp_dir_wildcard.c_str()));
 
   // Prepare the command to execute.
-  std::wstring command_write;
+  base::string16 command_write;
   command_write += L"File_Create Write \"";
   command_write += temp_file;
   command_write += L"\"";
 
   // Verify that we have write access to the original file
   EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(command_write.c_str()));
 
   // Replace the subfolder by a reparse point to %temp%.
   ::DeleteFile(temp_file.c_str());
   HANDLE dir = ::CreateFile(subfolder.c_str(), FILE_ALL_ACCESS,
                             FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                             OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
   EXPECT_TRUE(INVALID_HANDLE_VALUE != dir);
 
-  std::wstring temp_dir_nt;
+  base::string16 temp_dir_nt;
   temp_dir_nt += L"\\??\\";
   temp_dir_nt += temp_dir;
   EXPECT_TRUE(SetReparsePoint(dir, temp_dir_nt.c_str()));
   EXPECT_TRUE(::CloseHandle(dir));
 
   // Try to open the file again.
   EXPECT_EQ(SBOX_TEST_DENIED, runner.RunTest(command_write.c_str()));
 
   // Remove the reparse point.
   dir = ::CreateFile(subfolder.c_str(), FILE_ALL_ACCESS,
                      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                      FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
                      NULL);
   EXPECT_TRUE(INVALID_HANDLE_VALUE != dir);
   EXPECT_TRUE(DeleteReparsePoint(dir));
   EXPECT_TRUE(::CloseHandle(dir));
 
   // Cleanup.
   EXPECT_TRUE(::DeleteFile(temp_file_in_temp.c_str()));
   EXPECT_TRUE(::RemoveDirectory(subfolder.c_str()));
 }
 
 }  // namespace sandbox