Remove base/scoped_handle_win.h stub and fix up all callers to use the new location and namespace.

base/message_loop_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 <vector>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_pump_win.h"
-#include "base/scoped_handle.h"
+#include "base/win/scoped_handle.h"
 #endif
 #if defined(OS_POSIX)
 #include "base/message_pump_libevent.h"
 #endif
 
 using base::PlatformThread;
 using base::Thread;
 using base::Time;
 using base::TimeDelta;
 
@@ skipping 901 matching lines @@
 
 // A side effect of this test is the generation a beep. Sorry.
 void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveDenial2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
-  ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
+  base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   new Recursive2Tasks(MessageLoop::current(),
                                                       event,
                                                       true,
                                                       &order,
                                                       false));
   // Let the other thread execute.
   WaitForSingleObject(event, INFINITE);
   MessageLoop::current()->Run();
 
@@ skipping 22 matching lines @@
 // A side effect of this test is the generation a beep. Sorry.  This test also
 // needs to process windows messages on the current thread.
 void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveSupport2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
-  ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
+  base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   new Recursive2Tasks(MessageLoop::current(),
                                                       event,
                                                       false,
                                                       &order,
                                                       true));
   // Let the other thread execute.
   WaitForSingleObject(event, INFINITE);
   MessageLoop::current()->Run();
 
@@ skipping 186 matching lines @@
 
   void Init();
   void WaitForIO();
   OVERLAPPED* context() { return &context_.overlapped; }
   DWORD size() { return sizeof(buffer_); }
 
  private:
   char buffer_[48];
   MessageLoopForIO::IOContext context_;
   HANDLE signal_;
-  ScopedHandle file_;
+  base::win::ScopedHandle file_;
   bool wait_;
 };
 
 TestIOHandler::TestIOHandler(const wchar_t* name, HANDLE signal, bool wait)
     : signal_(signal), wait_(wait) {
   memset(buffer_, 0, sizeof(buffer_));
   memset(&context_, 0, sizeof(context_));
   context_.handler = this;
 
   file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
@@ skipping 27 matching lines @@
   explicit IOHandlerTask(TestIOHandler* handler) : handler_(handler) {}
   virtual void Run() {
     handler_->Init();
   }
 
  private:
   TestIOHandler* handler_;
 };
 
 void RunTest_IOHandler() {
-  ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
+  base::win::ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
   ASSERT_TRUE(callback_called.IsValid());
 
   const wchar_t* kPipeName = L"\\\\.\\pipe\\iohandler_pipe";
-  ScopedHandle server(CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1,
-                                      0, 0, 0, NULL));
+  base::win::ScopedHandle server(
+      CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
   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);
   IOHandlerTask* task = new IOHandlerTask(&handler);
   thread_loop->PostTask(FROM_HERE, task);
   Sleep(100);  // Make sure the thread runs and sleeps for lack of work.
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server, buffer, sizeof(buffer), &written, NULL));
 
   DWORD result = WaitForSingleObject(callback_called, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
 
 void RunTest_WaitForIO() {
-  ScopedHandle callback1_called(CreateEvent(NULL, TRUE, FALSE, NULL));
-  ScopedHandle callback2_called(CreateEvent(NULL, TRUE, FALSE, NULL));
+  base::win::ScopedHandle callback1_called(
+      CreateEvent(NULL, TRUE, FALSE, NULL));
+  base::win::ScopedHandle callback2_called(
+      CreateEvent(NULL, TRUE, FALSE, NULL));
   ASSERT_TRUE(callback1_called.IsValid());
   ASSERT_TRUE(callback2_called.IsValid());
 
   const wchar_t* kPipeName1 = L"\\\\.\\pipe\\iohandler_pipe1";
   const wchar_t* kPipeName2 = L"\\\\.\\pipe\\iohandler_pipe2";
-  ScopedHandle server1(CreateNamedPipe(kPipeName1, PIPE_ACCESS_OUTBOUND, 0, 1,
-                                       0, 0, 0, NULL));
-  ScopedHandle server2(CreateNamedPipe(kPipeName2, PIPE_ACCESS_OUTBOUND, 0, 1,
-                                       0, 0, 0, NULL));
+  base::win::ScopedHandle server1(
+      CreateNamedPipe(kPipeName1, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
+  base::win::ScopedHandle server2(
+      CreateNamedPipe(kPipeName2, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
   ASSERT_TRUE(server1.IsValid());
   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);
@@ skipping 414 matching lines @@
   loop->PostDelayedTask(
       FROM_HERE,
       new RunAtDestructionTask(&task_destroyed, &destruction_observer_called),
       kDelayMS);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }