Add HANDLE_FLAG_PROTECT_FROM_CLOSE flag to Tracked/ScopedHandle.

base/win/scoped_handle.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 "base/win/scoped_handle.h"
 
 #include <unordered_map>
 
 #include "base/debug/alias.h"
 #include "base/hash.h"
@@ skipping 114 matching lines @@
     g_active_verifier = new ActiveVerifier(false);
     return;
   }
 
   ActiveVerifier* verifier =
       reinterpret_cast<ActiveVerifier*>(get_handle_verifier());
 
   // This lock only protects against races in this module, which is fine.
   AutoNativeLock lock(g_lock.Get());
   g_active_verifier = verifier ? verifier : new ActiveVerifier(true);
-
-  // TODO(shrikant): Enable handle verifier after figuring out
-  // AppContainer/DuplicateHandle error.
-  g_active_verifier->Disable();
 #endif
 }
 
 bool ActiveVerifier::CloseHandle(HANDLE handle) {
   if (!enabled_)
     return CloseHandleWrapper(handle);
 
   AutoNativeLock lock(*lock_);
   closing_ = true;
   CloseHandleWrapper(handle);
   closing_ = false;
 
   return true;
 }
 
 void ActiveVerifier::StartTracking(HANDLE handle, const void* owner,
                                    const void* pc1, const void* pc2) {
   if (!enabled_)
     return;
 
+  // Idea here is to make our handles non-closable until we close it ourselves.
+  ::SetHandleInformation(handle, HANDLE_FLAG_PROTECT_FROM_CLOSE,
+                         HANDLE_FLAG_PROTECT_FROM_CLOSE);
+
   // Grab the thread id before the lock.
   DWORD thread_id = GetCurrentThreadId();
 
   AutoNativeLock lock(*lock_);
 
   Info handle_info = { owner, pc1, pc2, thread_id };
   std::pair<HANDLE, Info> item(handle, handle_info);
   std::pair<HandleMap::iterator, bool> result = map_.insert(item);
   if (!result.second) {
     Info other = result.first->second;
     base::debug::Alias(&other);
     CHECK(false);
   }
 }
 
 void ActiveVerifier::StopTracking(HANDLE handle, const void* owner,
                                   const void* pc1, const void* pc2) {
   if (!enabled_)
     return;
 
+  // We expect handle to be protected till this point.
+  DWORD flags = 0;
+  ::GetHandleInformation(handle, &flags);
+  if (!(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE))

[grt (UTC plus 2), 2015/05/01 13:26:14]

minor style nit: check what you care about rather than testing and then
CHECK(FALSE). for example:
CHECK_NE(0U, (flags & HANDLE_FLAG_PROTECT_FROM_CLOSE));

[Shrikant Kelkar, 2015/05/01 17:48:41]

Done.

+    CHECK(FALSE);
+
+  // Unprotect handle so that it could be closed.
+  ::SetHandleInformation(handle, HANDLE_FLAG_PROTECT_FROM_CLOSE, 0);
+
   AutoNativeLock lock(*lock_);
   HandleMap::iterator i = map_.find(handle);
   if (i == map_.end())
     CHECK(false);
 
   Info other = i->second;
   if (other.owner != owner) {
     base::debug::Alias(&other);
     CHECK(false);
   }
 
   map_.erase(i);
 }
 
 void ActiveVerifier::Disable() {
   enabled_ = false;
 }
 
 void ActiveVerifier::OnHandleBeingClosed(HANDLE handle) {
   AutoNativeLock lock(*lock_);
   if (closing_)
     return;
 
   HandleMap::iterator i = map_.find(handle);
   if (i == map_.end())
     return;
 
+  // Mask out all protected handle close attempts. This will give us
+  // idea if protecting handle has any effect or not.
+  // TODO(shrikant): Remove this code once we see results of the above
+  // mentioned experiment.
+  DWORD flags = 0;
+  ::GetHandleInformation(handle, &flags);
+  if (flags & HANDLE_FLAG_PROTECT_FROM_CLOSE)
+    return;
+
   Info other = i->second;
   base::debug::Alias(&other);
   CHECK(false);
 }
 
 }  // namespace
 
 void* GetHandleVerifier() {
   return g_active_verifier;
 }
@@ skipping 21 matching lines @@
 void DisableHandleVerifier() {
   return ActiveVerifier::Get()->Disable();
 }
 
 void OnHandleBeingClosed(HANDLE handle) {
   return ActiveVerifier::Get()->OnHandleBeingClosed(handle);
 }
 
 }  // namespace win
 }  // namespace base