SyncSocket Transit Descriptor - refactoring

media/audio/audio_output_device_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 <vector>
 
 #include "base/at_exit.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
@@ skipping 36 matching lines @@
 
   MOCK_METHOD3(CreateStream, void(AudioOutputIPCDelegate* delegate,
                                   const AudioParameters& params,
                                   int session_id));
   MOCK_METHOD0(PlayStream, void());
   MOCK_METHOD0(PauseStream, void());
   MOCK_METHOD0(CloseStream, void());
   MOCK_METHOD1(SetVolume, void(double volume));
 };
 
-// Creates a copy of a SyncSocket handle that we can give to AudioOutputDevice.
-// On Windows this means duplicating the pipe handle so that AudioOutputDevice
-// can call CloseHandle() (since ownership has been transferred), but on other
-// platforms, we just copy the same socket handle since AudioOutputDevice on
-// those platforms won't actually own the socket (FileDescriptor.auto_close is
-// false).
-bool DuplicateSocketHandle(SyncSocket::Handle socket_handle,
-                           SyncSocket::Handle* copy) {
-#if defined(OS_WIN)
-  HANDLE process = GetCurrentProcess();
-  ::DuplicateHandle(process, socket_handle, process, copy,
-                    0, FALSE, DUPLICATE_SAME_ACCESS);
-  return *copy != NULL;
-#else
-  *copy = socket_handle;
-  return *copy != -1;
-#endif
-}
-
 ACTION_P2(SendPendingBytes, socket, pending_bytes) {
   socket->Send(&pending_bytes, sizeof(pending_bytes));
 }
 
 // Used to terminate a loop from a different thread than the loop belongs to.
 // |loop| should be a MessageLoopProxy.
 ACTION_P(QuitLoop, loop) {
   loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
@@ skipping 27 matching lines @@
 
   SharedMemory shared_memory_;
   CancelableSyncSocket browser_socket_;
   CancelableSyncSocket renderer_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceTest);
 };
 
 int AudioOutputDeviceTest::CalculateMemorySize() {
   // Calculate output memory size.
- return AudioBus::CalculateMemorySize(default_audio_parameters_);
+  return AudioBus::CalculateMemorySize(default_audio_parameters_);
 }
 
 AudioOutputDeviceTest::AudioOutputDeviceTest() {
   default_audio_parameters_.Reset(
       AudioParameters::AUDIO_PCM_LINEAR,
       CHANNEL_LAYOUT_STEREO, 2, 48000, 16, 1024);
 
   audio_output_ipc_ = new MockAudioOutputIPC();
   audio_device_ = new AudioOutputDevice(
       scoped_ptr<AudioOutputIPC>(audio_output_ipc_),
@@ skipping 22 matching lines @@
 
   ASSERT_TRUE(shared_memory_.CreateAndMapAnonymous(kMemorySize));
   memset(shared_memory_.memory(), 0xff, kMemorySize);
 
   ASSERT_TRUE(CancelableSyncSocket::CreatePair(&browser_socket_,
                                                &renderer_socket_));
 
   // Create duplicates of the handles we pass to AudioOutputDevice since
   // ownership will be transferred and AudioOutputDevice is responsible for
   // freeing.
-  SyncSocket::Handle audio_device_socket = SyncSocket::kInvalidHandle;
-  ASSERT_TRUE(DuplicateSocketHandle(renderer_socket_.handle(),
-                                    &audio_device_socket));
+  SyncSocket::TransitDescriptor audio_device_socket_descriptor;
+  ASSERT_TRUE(renderer_socket_.PrepareTransitDescriptor(
+      base::GetCurrentProcessHandle(), &audio_device_socket_descriptor));
   base::SharedMemoryHandle duplicated_memory_handle;
   ASSERT_TRUE(shared_memory_.ShareToProcess(base::GetCurrentProcessHandle(),
                                             &duplicated_memory_handle));
 
-  audio_device_->OnStreamCreated(duplicated_memory_handle, audio_device_socket,
-                                 kMemorySize);
+  audio_device_->OnStreamCreated(
+      duplicated_memory_handle,
+      SyncSocket::UnwrapHandle(audio_device_socket_descriptor), kMemorySize);
   io_loop_.RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::ExpectRenderCallback() {
   // We should get a 'play' notification when we call OnStreamCreated().
   // Respond by asking for some audio data.  This should ask our callback
   // to provide some audio data that AudioOutputDevice then writes into the
   // shared memory section.
   const int kMemorySize = CalculateMemorySize();
 
@@ skipping 68 matching lines @@
   StartAudioDevice();
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.