Remove implicit HANDLE conversions from base.

base/win/event_trace_consumer_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.
 //
 // Unit tests for event trace consumer base class.
 #include "base/win/event_trace_consumer.h"
 
 #include <list>
 
 #include <objbase.h>
@@ skipping 131 matching lines @@
     return consumer_.Consume();
   }
 
   static DWORD WINAPI ConsumerThreadMainProc(void* arg) {
     return reinterpret_cast<EtwTraceConsumerRealtimeTest*>(arg)->
         ConsumerThread();
   }
 
   HRESULT StartConsumerThread() {
     consumer_ready_.Set(::CreateEvent(NULL, TRUE, FALSE, NULL));
-    EXPECT_TRUE(consumer_ready_ != NULL);
+    EXPECT_TRUE(consumer_ready_.IsValid());
     consumer_thread_.Set(::CreateThread(NULL, 0, ConsumerThreadMainProc, this,
                                         0, NULL));
     if (consumer_thread_.Get() == NULL)
       return HRESULT_FROM_WIN32(::GetLastError());
 
-    HANDLE events[] = { consumer_ready_, consumer_thread_ };
+    HANDLE events[] = { consumer_ready_.Get(), consumer_thread_.Get() };
     DWORD result = ::WaitForMultipleObjects(arraysize(events), events,
                                             FALSE, INFINITE);
     switch (result) {
       case WAIT_OBJECT_0:
         // The event was set, the consumer_ is ready.
         return S_OK;
       case WAIT_OBJECT_0 + 1: {
           // The thread finished. This may race with the event, so check
           // explicitly for the event here, before concluding there's trouble.
-          if (::WaitForSingleObject(consumer_ready_, 0) == WAIT_OBJECT_0)
+          if (::WaitForSingleObject(consumer_ready_.Get(), 0) == WAIT_OBJECT_0)
             return S_OK;
           DWORD exit_code = 0;
-          if (::GetExitCodeThread(consumer_thread_, &exit_code))
+          if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
             return exit_code;
           return HRESULT_FROM_WIN32(::GetLastError());
         }
       default:
         return E_UNEXPECTED;
     }
   }
 
   // Waits for consumer_ thread to exit, and returns its exit code.
   HRESULT JoinConsumerThread() {
-    if (::WaitForSingleObject(consumer_thread_, INFINITE) != WAIT_OBJECT_0)
+    if (::WaitForSingleObject(consumer_thread_.Get(), INFINITE) !=
+        WAIT_OBJECT_0) {
       return HRESULT_FROM_WIN32(::GetLastError());
+    }
 
     DWORD exit_code = 0;
-    if (::GetExitCodeThread(consumer_thread_, &exit_code))
+    if (::GetExitCodeThread(consumer_thread_.Get(), &exit_code))
       return exit_code;
 
     return HRESULT_FROM_WIN32(::GetLastError());
   }
 
   TestConsumer consumer_;
   ScopedHandle consumer_ready_;
   ScopedHandle consumer_thread_;
 };
 
 }  // namespace
 
 TEST_F(EtwTraceConsumerRealtimeTest, ConsumerReturnsWhenSessionClosed) {
   EtwTraceController controller;
   if (controller.StartRealtimeSession(session_name_.c_str(), 100 * 1024) ==
       E_ACCESSDENIED) {
     VLOG(1) << "You must be an administrator to run this test on Vista";
     return;
   }
 
   // Start the consumer_.
   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
 
   // Wait around for the consumer_ thread a bit.
-  ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_, 50));
+  ASSERT_EQ(WAIT_TIMEOUT, ::WaitForSingleObject(consumer_thread_.Get(), 50));
   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
 
   // The consumer_ returns success on session stop.
   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
 }
 
 namespace {
 
 // {57E47923-A549-476f-86CA-503D57F59E62}
 DEFINE_GUID(
@@ skipping 15 matching lines @@
 
   EtwTraceProvider provider(test_provider_);
   ASSERT_EQ(ERROR_SUCCESS, provider.Register());
 
   // Start the consumer_.
   ASSERT_HRESULT_SUCCEEDED(StartConsumerThread());
   ASSERT_EQ(0, TestConsumer::events_.size());
 
   EtwMofEvent<1> event(kTestEventType, 1, TRACE_LEVEL_ERROR);
   EXPECT_EQ(ERROR_SUCCESS, provider.Log(&event.header));
-  EXPECT_EQ(WAIT_OBJECT_0, ::WaitForSingleObject(TestConsumer::sank_event_,
-                                                 INFINITE));
+  EXPECT_EQ(WAIT_OBJECT_0,
+            ::WaitForSingleObject(TestConsumer::sank_event_.Get(), INFINITE));
   ASSERT_HRESULT_SUCCEEDED(controller.Stop(NULL));
   ASSERT_HRESULT_SUCCEEDED(JoinConsumerThread());
   ASSERT_NE(0u, TestConsumer::events_.size());
 }
 
 namespace {
 
 // We run events through a file session to assert that
 // the content comes through.
 class EtwTraceConsumerDataTest: public EtwTraceConsumerBaseTest {
@@ skipping 97 matching lines @@
     return;
   }
   ASSERT_HRESULT_SUCCEEDED(hr) << "RoundTripEvent failed";
   ASSERT_TRUE(trace != NULL);
   ASSERT_EQ(sizeof(kData), trace->MofLength);
   ASSERT_STREQ(kData, reinterpret_cast<const char*>(trace->MofData));
 }
 
 }  // namespace win
 }  // namespace base