Base: Remove Receive() from ScopedHandle.

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 325 matching lines @@
   EXPECT_TRUE(event_handler_);
   EXPECT_FALSE(worker_process_.IsValid());
 
   WCHAR notepad[MAX_PATH + 1];
   ASSERT_GT(ExpandEnvironmentStrings(
       L"\045SystemRoot\045\\system32\\notepad.exe", notepad, MAX_PATH), 0u);
 
   STARTUPINFOW startup_info = { 0 };
   startup_info.cb = sizeof(startup_info);
 
-  base::win::ScopedProcessInformation process_information;
+  PROCESS_INFORMATION temp_process_info = {};
   ASSERT_TRUE(CreateProcess(NULL,
                             notepad,
                             NULL,   // default process attibutes
                             NULL,   // default thread attibutes
                             FALSE,  // do not inherit handles
                             CREATE_SUSPENDED,
                             NULL,   // no environment
                             NULL,   // default current directory
                             &startup_info,
-                            process_information.Receive()));
+                            &temp_process_info));
+  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_.reset(new IPC::ChannelProxy(
       IPC::ChannelHandle(pipe),
       IPC::Channel::MODE_SERVER,
       this,
       task_runner_));
 
-  ScopedHandle copy;
+  HANDLE temp_handle;
   ASSERT_TRUE(DuplicateHandle(GetCurrentProcess(),
                               worker_process_,
                               GetCurrentProcess(),
-                              copy.Receive(),
+                              &temp_handle,
                               0,
                               FALSE,
                               DUPLICATE_SAME_ACCESS));
+  ScopedHandle copy;
+  copy.Set(temp_handle);
 
   event_handler_->OnProcessLaunched(copy.Pass());
 }
 
 TEST_F(WorkerProcessLauncherTest, Start) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(1)
       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::LaunchProcess));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
@@ skipping 136 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting