Resolve registry root paths in HandleCloser

sandbox/win/src/handle_closer.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 "sandbox/win/src/handle_closer.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/windows_version.h"
 #include "sandbox/win/src/interceptors.h"
@@ skipping 21 matching lines @@
 // Memory buffer mapped from the parent, with the list of handles.
 SANDBOX_INTERCEPT HandleCloserInfo* g_handles_to_close;
 
 HandleCloser::HandleCloser() {}
 
 ResultCode HandleCloser::AddHandle(const base::char16* handle_type,
                                    const base::char16* handle_name) {
   if (!handle_type)
     return SBOX_ERROR_BAD_PARAMS;
 
+  base::string16 resolved_name;
+  if (handle_name) {
+    resolved_name = handle_name;
+    if (handle_type == base::string16(L"Key"))

[cpu_(ooo_6.6-7.5), 2014/08/13 23:18:35]

can you use == L"key"; so avoids constructing a string object in the hopes that
there is an std::string::operator=(const wchar_t*) ?

else

lgtm

Are there tests for ResolveRegistryName? if not we should add one.

+      if (!ResolveRegistryName(resolved_name, &resolved_name))
+        return SBOX_ERROR_BAD_PARAMS;
+  }
+
   HandleMap::iterator names = handles_to_close_.find(handle_type);
   if (names == handles_to_close_.end()) {  // We have no entries for this type.
     std::pair<HandleMap::iterator, bool> result = handles_to_close_.insert(
         HandleMap::value_type(handle_type, HandleMap::mapped_type()));
     names = result.first;
     if (handle_name)
-      names->second.insert(handle_name);
+      names->second.insert(resolved_name);
   } else if (!handle_name) {  // Now we need to close all handles of this type.
     names->second.clear();
   } else if (!names->second.empty()) {  // Add another name for this type.
-    names->second.insert(handle_name);
+    names->second.insert(resolved_name);
   }  // If we're already closing all handles of type then we're done.
 
   return SBOX_ALL_OK;
 }
 
 size_t HandleCloser::GetBufferSize() {
   size_t bytes_total = offsetof(HandleCloserInfo, handle_entries);
 
   for (HandleMap::iterator i = handles_to_close_.begin();
        i != handles_to_close_.end(); ++i) {
@@ skipping 110 matching lines @@
 
   if (NT_SUCCESS(result) && name->Buffer && name->Length)
     handle_name->assign(name->Buffer, name->Length / sizeof(wchar_t));
   else
     handle_name->clear();
 
   return NT_SUCCESS(result);
 }
 
 }  // namespace sandbox