Check for CloseHandle failures even when not debugging

base/time/time_win_unittest.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 <windows.h>
 #include <mmsystem.h>
 #include <process.h>
 
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
+#include "base/win/scoped_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using base::TraceTicks;
 
 namespace {
 
 class MockTimeTicks : public TimeTicks {
@@ skipping 54 matching lines @@
   const int kThreads = 8;
   // Use int64 so we can cast into a void* without a compiler warning.
   const int64 kChecks = 10;
 
   // It takes a lot of iterations to reproduce the bug!
   // (See bug 1081395)
   for (int loop = 0; loop < 4096; loop++) {
     // Setup
     MockTimeTicks::InstallTicker();
     g_rollover_test_start = CreateEvent(0, TRUE, FALSE, 0);
-    HANDLE threads[kThreads];
+    // Since using _beginthreadex() (as opposed to _beginthread), make sure
+    // CloseHandle is called.
+    base::win::ScopedHandle threads[kThreads];
 
     for (int index = 0; index < kThreads; index++) {
       void* argument = reinterpret_cast<void*>(kChecks);
       unsigned thread_id;
-      threads[index] = reinterpret_cast<HANDLE>(
+      threads[index].Set(reinterpret_cast<HANDLE>(
         _beginthreadex(NULL, 0, RolloverTestThreadMain, argument, 0,
-          &thread_id));
-      EXPECT_NE((HANDLE)NULL, threads[index]);
+          &thread_id)));
+      EXPECT_EQ(true, threads[index].IsValid());
     }
 
     // Start!
     SetEvent(g_rollover_test_start);
 
     // Wait for threads to finish
     for (int index = 0; index < kThreads; index++) {
-      DWORD rv = WaitForSingleObject(threads[index], INFINITE);
+      DWORD rv = WaitForSingleObject(threads[index].Get(), INFINITE);
       EXPECT_EQ(rv, WAIT_OBJECT_0);
-      // Since using _beginthreadex() (as opposed to _beginthread),
-      // an explicit CloseHandle() is supposed to be called.
-      CloseHandle(threads[index]);
     }
 
-    CloseHandle(g_rollover_test_start);
+    CHECK(::CloseHandle(g_rollover_test_start));
 
     // Teardown
     MockTimeTicks::UninstallTicker();
   }
 }
 
 TEST(TimeTicks, SubMillisecondTimers) {
   // IsHighResolution() is false on some systems.  Since the product still works
   // even if it's false, it makes this entire test questionable.
   if (!TimeTicks::IsHighResolution())
@@ skipping 136 matching lines @@
     const TimeTicks converted_value = TimeTicks::FromQPCValue(ticks);
     const double converted_microseconds_since_origin =
         static_cast<double>((converted_value - TimeTicks()).InMicroseconds());
     EXPECT_NEAR(expected_microseconds_since_origin,
                 converted_microseconds_since_origin,
                 1.0)
         << "ticks=" << ticks << ", to be converted via logic path: "
         << (ticks < Time::kQPCOverflowThreshold ? "FAST" : "SAFE");
   }
 }