Remove implicit HANDLE conversions from base.

base/message_loop/message_loop_unittest.cc

 // Copyright 2013 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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 315 matching lines @@
   TaskList order;
   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              true,
                                              &order,
                                              false));
   // Let the other thread execute.
-  WaitForSingleObject(event, INFINITE);
+  WaitForSingleObject(event.Get(), INFINITE);
   MessageLoop::current()->Run();
 
   ASSERT_EQ(order.Size(), 17);
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(MESSAGEBOX, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 3, false));
   // When EndDialogFunc is processed, the window is already dismissed, hence no
@@ skipping 23 matching lines @@
   TaskList order;
   win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              false,
                                              &order,
                                              true));
   // Let the other thread execute.
-  WaitForSingleObject(event, INFINITE);
+  WaitForSingleObject(event.Get(), INFINITE);
   MessageLoop::current()->Run();
 
   ASSERT_EQ(order.Size(), 18);
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   // Note that this executes in the MessageBox modal loop.
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
@@ skipping 119 matching lines @@
   memset(buffer_, 0, sizeof(buffer_));
   memset(&context_, 0, sizeof(context_));
   context_.handler = this;
 
   file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
                        FILE_FLAG_OVERLAPPED, NULL));
   EXPECT_TRUE(file_.IsValid());
 }
 
 void TestIOHandler::Init() {
-  MessageLoopForIO::current()->RegisterIOHandler(file_, this);
+  MessageLoopForIO::current()->RegisterIOHandler(file_.Get(), this);
 
   DWORD read;
-  EXPECT_FALSE(ReadFile(file_, buffer_, size(), &read, context()));
+  EXPECT_FALSE(ReadFile(file_.Get(), buffer_, size(), &read, context()));
   EXPECT_EQ(ERROR_IO_PENDING, GetLastError());
   if (wait_)
     WaitForIO();
 }
 
 void TestIOHandler::OnIOCompleted(MessageLoopForIO::IOContext* context,
                                   DWORD bytes_transfered, DWORD error) {
   ASSERT_TRUE(context == &context_);
   ASSERT_TRUE(SetEvent(signal_));
 }
@@ skipping 13 matching lines @@
   ASSERT_TRUE(server.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
-  TestIOHandler handler(kPipeName, callback_called, false);
+  TestIOHandler handler(kPipeName, callback_called.Get(), false);
   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
                                               Unretained(&handler)));
   // Make sure the thread runs and sleeps for lack of work.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 
   const char buffer[] = "Hello there!";
   DWORD written;
-  EXPECT_TRUE(WriteFile(server, buffer, sizeof(buffer), &written, NULL));
+  EXPECT_TRUE(WriteFile(server.Get(), buffer, sizeof(buffer), &written, NULL));
 
-  DWORD result = WaitForSingleObject(callback_called, 1000);
+  DWORD result = WaitForSingleObject(callback_called.Get(), 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
 
 void RunTest_WaitForIO() {
   win::ScopedHandle callback1_called(
       CreateEvent(NULL, TRUE, FALSE, NULL));
   win::ScopedHandle callback2_called(
       CreateEvent(NULL, TRUE, FALSE, NULL));
@@ skipping 10 matching lines @@
   ASSERT_TRUE(server2.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
-  TestIOHandler handler1(kPipeName1, callback1_called, false);
-  TestIOHandler handler2(kPipeName2, callback2_called, true);
+  TestIOHandler handler1(kPipeName1, callback1_called.Get(), false);
+  TestIOHandler handler2(kPipeName2, callback2_called.Get(), true);
   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
                                               Unretained(&handler1)));
   // TODO(ajwong): Do we really need such long Sleeps in ths function?
   // Make sure the thread runs and sleeps for lack of work.
   TimeDelta delay = TimeDelta::FromMilliseconds(100);
   PlatformThread::Sleep(delay);
   thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
                                               Unretained(&handler2)));
   PlatformThread::Sleep(delay);
 
   // At this time handler1 is waiting to be called, and the thread is waiting
   // on the Init method of handler2, filtering only handler2 callbacks.
 
   const char buffer[] = "Hello there!";
   DWORD written;
-  EXPECT_TRUE(WriteFile(server1, buffer, sizeof(buffer), &written, NULL));
+  EXPECT_TRUE(WriteFile(server1.Get(), buffer, sizeof(buffer), &written, NULL));
   PlatformThread::Sleep(2 * delay);
-  EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called, 0)) <<
+  EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called.Get(), 0)) <<
       "handler1 has not been called";
 
-  EXPECT_TRUE(WriteFile(server2, buffer, sizeof(buffer), &written, NULL));
+  EXPECT_TRUE(WriteFile(server2.Get(), buffer, sizeof(buffer), &written, NULL));
 
   HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
   DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
 
 #endif  // defined(OS_WIN)
 
@@ skipping 376 matching lines @@
 
   ASSERT_TRUE(PostMessage(message_hwnd, kSignalMsg, 0, 1));
 
   loop.Run();
 
   ASSERT_TRUE(UnregisterClass(MAKEINTATOM(atom), instance));
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace base