Had a bug in the handle table unit test.

sandbox/src/handle_table.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/src/handle_table.h"
 
 #include <algorithm>
 #include <cstdlib>
 
 #include "base/memory/scoped_ptr.h"
 #include "sandbox/src/win_utils.h"
 
 namespace {
 
 bool CompareHandleEntries(const SYSTEM_HANDLE_INFORMATION& a,
                           const SYSTEM_HANDLE_INFORMATION& b) {
   return a.ProcessId < b.ProcessId;
 }
 
+static NtQueryObject QueryObject = NULL;
+
 }  // namespace
 
 namespace sandbox {
 
 const char16* HandleTable::kTypeProcess = L"Process";
 const char16* HandleTable::kTypeThread = L"Thread";
 const char16* HandleTable::kTypeFile = L"File";
 const char16* HandleTable::kTypeDirectory = L"Directory";
 const char16* HandleTable::kTypeKey = L"Key";
 const char16* HandleTable::kTypeWindowStation = L"WindowStation";
@@ skipping 47 matching lines @@
   finish = std::upper_bound(start, finish, key, CompareHandleEntries);
   return Iterator(*this, start, finish);
 }
 
 HandleTable::HandleEntry::HandleEntry(
     const SYSTEM_HANDLE_INFORMATION* handle_info_entry)
     : handle_entry_(handle_info_entry), last_entry_(0) {
 }
 
 void HandleTable::HandleEntry::UpdateInfo(UpdateType flag) {
-  static NtQueryObject QueryObject = NULL;
   if (!QueryObject)
     ResolveNTFunctionPtr("NtQueryObject", &QueryObject);
 
   NTSTATUS result;
 
   // Always update the basic type info, but grab the names as needed.
   if (needs_info_update()) {
     handle_name_.clear();
     type_name_.clear();
     last_entry_ = handle_entry_;
@@ skipping 14 matching lines @@
     if (!NT_SUCCESS(result)) {
       type_info_buffer_.clear();
       return;
     }
   }
 
   // Don't bother copying out names until we ask for them, and then cache them.
   switch (flag) {
     case UPDATE_INFO_AND_NAME:
       if (type_info_buffer_.size() && handle_name_.empty()) {
-        ULONG size = MAX_PATH;
-        scoped_ptr<UNICODE_STRING> name;
-        do {
-          name.reset(reinterpret_cast<UNICODE_STRING*>(new BYTE[size]));
-          result = QueryObject(reinterpret_cast<HANDLE>(
-              handle_entry_->Handle), ObjectNameInformation, name.get(),
-              size, &size);
-        } while (result == STATUS_INFO_LENGTH_MISMATCH);
-
-        if (NT_SUCCESS(result)) {
-          handle_name_.assign(name->Buffer, name->Length / sizeof(wchar_t));
-        }
+        GetHandleName(reinterpret_cast<HANDLE>(handle_entry_->Handle),
+            &handle_name_);
       }
       break;
 
     case UPDATE_INFO_AND_TYPE_NAME:
       if (!type_info_buffer_.empty() && type_info_internal()->Name.Buffer &&
           type_name_.empty()) {
         type_name_.assign(type_info_internal()->Name.Buffer,
             type_info_internal()->Name.Length / sizeof(wchar_t));
       }
       break;
   }
 }
 
+// Returns the object manager's name associated with a handle
+BOOL GetHandleName(HANDLE handle, string16* handle_name) {
+  if (!QueryObject)
+    ResolveNTFunctionPtr("NtQueryObject", &QueryObject);
+
+  ULONG size = MAX_PATH;
+  scoped_ptr<UNICODE_STRING> name;
+  NTSTATUS result;
+
+  do {
+    name.reset(reinterpret_cast<UNICODE_STRING*>(new BYTE[size]));
+    result = QueryObject(handle, ObjectNameInformation, name.get(),
+                         size, &size);
+  } while (result == STATUS_INFO_LENGTH_MISMATCH);
+
+  if (NT_SUCCESS(result))
+    handle_name->assign(name->Buffer, name->Length / sizeof(wchar_t));
+
+  return NT_SUCCESS(result);
+}
+
 const OBJECT_TYPE_INFORMATION* HandleTable::HandleEntry::TypeInfo() {
   UpdateInfo(UPDATE_INFO_ONLY);
   return type_info_buffer_.empty() ? NULL : type_info_internal();
 }
 
 const string16& HandleTable::HandleEntry::Name() {
   UpdateInfo(UPDATE_INFO_AND_NAME);
   return handle_name_;
 }
 
@@ skipping 15 matching lines @@
                                 const SYSTEM_HANDLE_INFORMATION* start,
                                 const SYSTEM_HANDLE_INFORMATION* end)
     : table_(table), current_(start), end_(end) {
 }
 
 HandleTable::Iterator::Iterator(const Iterator& it)
     : table_(it.table_), current_(it.current_.handle_entry_), end_(it.end_) {
 }
 
 }  // namespace sandbox