Remove implicit HANDLE conversions from remoting.

remoting/host/win/worker_process_launcher_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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
@@ skipping 244 matching lines @@
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WorkerProcessLauncherTest::StopWorker,
                  base::Unretained(this)));
 }
 
 void WorkerProcessLauncherTest::KillProcess() {
   event_handler_ = NULL;
 
   if (worker_process_.IsValid()) {
-    TerminateProcess(worker_process_, CONTROL_C_EXIT);
+    TerminateProcess(worker_process_.Get(), CONTROL_C_EXIT);
     worker_process_.Close();
   }
 }
 
 void WorkerProcessLauncherTest::TerminateWorker(DWORD exit_code) {
   if (worker_process_.IsValid())
-    TerminateProcess(worker_process_, exit_code);
+    TerminateProcess(worker_process_.Get(), exit_code);
 }
 
 void WorkerProcessLauncherTest::ConnectClient() {
   channel_client_ = IPC::ChannelProxy::Create(IPC::ChannelHandle(channel_name_),
                                               IPC::Channel::MODE_CLIENT,
                                               &client_listener_,
                                               task_runner_);
 
   // Pretend that |kLaunchSuccessTimeoutSeconds| passed since launching
   // the worker process. This will make the backoff algorithm think that this
@@ skipping 72 matching lines @@
   base::win::ScopedProcessInformation process_information(temp_process_info);
   worker_process_.Set(process_information.TakeProcessHandle());
   ASSERT_TRUE(worker_process_.IsValid());
 
   channel_name_ = IPC::Channel::GenerateUniqueRandomChannelID();
   ScopedHandle pipe;
   ASSERT_TRUE(CreateIpcChannel(channel_name_, kIpcSecurityDescriptor, &pipe));
 
   // Wrap the pipe into an IPC channel.
   channel_server_ = IPC::ChannelProxy::Create(
-      IPC::ChannelHandle(pipe), IPC::Channel::MODE_SERVER, this, task_runner_);
+      IPC::ChannelHandle(pipe.Get()), IPC::Channel::MODE_SERVER, this,
+      task_runner_);
 
   HANDLE temp_handle;
   ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(),
-                              worker_process_,
+                              worker_process_.Get(),
                               GetCurrentProcess(),
                               &temp_handle,
                               0,
                               FALSE,
                               DUPLICATE_SAME_ACCESS));
   ScopedHandle copy(temp_handle);
 
   event_handler_->OnProcessLaunched(copy.Pass());
 }
 
@@ skipping 142 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting