Replace wstring with string16 in sandbox

sandbox/win/src/sync_policy.cc

 // Copyright (c) 2006-2008 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 <string>
 
 #include "sandbox/win/src/sync_policy.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "sandbox/win/src/ipc_tags.h"
 #include "sandbox/win/src/nt_internals.h"
 #include "sandbox/win/src/policy_engine_opcodes.h"
 #include "sandbox/win/src/policy_params.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "sandbox/win/src/sandbox_utils.h"
 #include "sandbox/win/src/sync_interception.h"
 #include "sandbox/win/src/win_utils.h"
 
 namespace sandbox {
 
 // Provides functionality to resolve a symbolic link within the object
 // directory passed in.
-NTSTATUS ResolveSymbolicLink(const std::wstring& directory_name,
-                             const std::wstring& name,
-                             std::wstring* target) {
+NTSTATUS ResolveSymbolicLink(const base::string16& directory_name,
+                             const base::string16& name,
+                             base::string16* target) {
   NtOpenDirectoryObjectFunction NtOpenDirectoryObject = NULL;
   ResolveNTFunctionPtr("NtOpenDirectoryObject", &NtOpenDirectoryObject);
 
   NtQuerySymbolicLinkObjectFunction NtQuerySymbolicLinkObject = NULL;
   ResolveNTFunctionPtr("NtQuerySymbolicLinkObject",
                        &NtQuerySymbolicLinkObject);
 
   NtOpenSymbolicLinkObjectFunction NtOpenSymbolicLinkObject = NULL;
   ResolveNTFunctionPtr("NtOpenSymbolicLinkObject", &NtOpenSymbolicLinkObject);
 
@@ skipping 63 matching lines @@
     *directory = base_named_objects_handle;
     return STATUS_SUCCESS;
   }
 
   NtOpenDirectoryObjectFunction NtOpenDirectoryObject = NULL;
   ResolveNTFunctionPtr("NtOpenDirectoryObject", &NtOpenDirectoryObject);
 
   DWORD session_id = 0;
   ProcessIdToSessionId(::GetCurrentProcessId(), &session_id);
 
-  std::wstring base_named_objects_path;
+  base::string16 base_named_objects_path;
 
   NTSTATUS status = ResolveSymbolicLink(L"\\Sessions\\BNOLINKS",
                                         base::StringPrintf(L"%d", session_id),
                                         &base_named_objects_path);
   if (status != STATUS_SUCCESS) {
     DLOG(ERROR) << "Failed to resolve BaseNamedObjects path. Error: "
                 << status;
     return status;
   }
 
   UNICODE_STRING directory_name = {};
   OBJECT_ATTRIBUTES object_attributes = {};
   InitObjectAttribs(base_named_objects_path, OBJ_CASE_INSENSITIVE, NULL,
                     &object_attributes, &directory_name);
   status = NtOpenDirectoryObject(&base_named_objects_handle,
                                  DIRECTORY_ALL_ACCESS,
                                  &object_attributes);
   if (status == STATUS_SUCCESS)
     *directory = base_named_objects_handle;
   return status;
 }
 
 bool SyncPolicy::GenerateRules(const wchar_t* name,
                                TargetPolicy::Semantics semantics,
                                LowLevelPolicy* policy) {
-  std::wstring mod_name(name);
+  base::string16 mod_name(name);
   if (mod_name.empty()) {
     return false;
   }
 
   if (TargetPolicy::EVENTS_ALLOW_ANY != semantics &&
       TargetPolicy::EVENTS_ALLOW_READONLY != semantics) {
     // Other flags are not valid for sync policy yet.
     NOTREACHED();
     return false;
   }
@@ skipping 24 matching lines @@
 
     if (!policy->AddRule(IPC_CREATEEVENT_TAG, &create))
       return false;
   }
 
   return true;
 }
 
 DWORD SyncPolicy::CreateEventAction(EvalResult eval_result,
                                     const ClientInfo& client_info,
-                                    const std::wstring &event_name,
+                                    const base::string16 &event_name,
                                     uint32 event_type,
                                     uint32 initial_state,
                                     HANDLE *handle) {
   NtCreateEventFunction NtCreateEvent = NULL;
   ResolveNTFunctionPtr("NtCreateEvent", &NtCreateEvent);
 
   // The only action supported is ASK_BROKER which means create the requested
   // file as specified.
   if (ASK_BROKER != eval_result)
     return false;
@@ skipping 17 matching lines @@
   if (!::DuplicateHandle(::GetCurrentProcess(), local_handle,
                          client_info.process, handle, 0, FALSE,
                          DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) {
     return STATUS_ACCESS_DENIED;
   }
   return status;
 }
 
 DWORD SyncPolicy::OpenEventAction(EvalResult eval_result,
                                   const ClientInfo& client_info,
-                                  const std::wstring &event_name,
+                                  const base::string16 &event_name,
                                   uint32 desired_access,
                                   HANDLE *handle) {
   NtOpenEventFunction NtOpenEvent = NULL;
   ResolveNTFunctionPtr("NtOpenEvent", &NtOpenEvent);
 
   // The only action supported is ASK_BROKER which means create the requested
   // event as specified.
   if (ASK_BROKER != eval_result)
     return false;
 
@@ skipping 14 matching lines @@
 
   if (!::DuplicateHandle(::GetCurrentProcess(), local_handle,
                          client_info.process, handle, 0, FALSE,
                          DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) {
     return STATUS_ACCESS_DENIED;
   }
   return status;
 }
 
 }  // namespace sandbox