Switch AudioDevice classes from SyncSocket to CancelableSyncSocket.

content/renderer/media/audio_device.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 "content/renderer/media/audio_device.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 225 matching lines @@
   // Takes care of the case when Stop() is called before OnLowLatencyCreated().
   if (!stream_id_) {
     base::SharedMemory::CloseHandle(handle);
     // Close the socket handler.
     base::SyncSocket socket(socket_handle);
     return;
   }
 
   shared_memory_handle_ = handle;
   memory_length_ = length;
-  audio_socket_ = new AudioSocket(socket_handle);
+  audio_socket_.reset(new base::CancelableSyncSocket(socket_handle));
 
   audio_thread_.reset(
       new base::DelegateSimpleThread(this, "renderer_audio_thread"));
   audio_thread_->Start();
 
   // We handle the case where Play() and/or Pause() may have been called
   // multiple times before OnLowLatencyCreated() gets called.
   is_started_ = true;
   if (play_on_start_)
     PlayOnIOThread();
 }
 
 void AudioDevice::OnVolume(double volume) {
   NOTIMPLEMENTED();
 }
 
 void AudioDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 // Our audio thread runs here.
 void AudioDevice::Run() {
   audio_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   base::SharedMemory shared_memory(shared_memory_handle_, false);
   shared_memory.Map(media::TotalSharedMemorySizeInBytes(memory_length_));
-  scoped_refptr<AudioSocket> audio_socket(audio_socket_);
+  base::CancelableSyncSocket* audio_socket = audio_socket_.get();
 
   int pending_data;
   const int samples_per_ms = static_cast<int>(sample_rate_) / 1000;
   const int bytes_per_ms = channels_ * (bits_per_sample_ / 8) * samples_per_ms;
 
-  while (sizeof(pending_data) ==
-      audio_socket->socket()->Receive(&pending_data, sizeof(pending_data))) {
+  size_t bytes_read = 0U;
+  while (true) {
+    bytes_read = audio_socket->Receive(&pending_data, sizeof(pending_data));
+    if (bytes_read != sizeof(pending_data))
+      break;
+
     if (pending_data == media::AudioOutputController::kPauseMark) {
       memset(shared_memory.memory(), 0, memory_length_);
       media::SetActualDataSizeInBytes(&shared_memory, memory_length_, 0);
       continue;
     } else if (pending_data < 0) {
       break;
     }
 
     // Convert the number of pending bytes in the render buffer
     // into milliseconds.
     audio_delay_milliseconds_ = pending_data / bytes_per_ms;
     size_t num_frames = FireRenderCallback(
         reinterpret_cast<int16*>(shared_memory.memory()));
 
     // Let the host know we are done.
     media::SetActualDataSizeInBytes(&shared_memory,
                                     memory_length_,
                                     num_frames * channels_ * sizeof(int16));
   }
-  audio_socket->Close();
+  DCHECK_EQ(bytes_read, 0U);
 }
 
 size_t AudioDevice::FireRenderCallback(int16* data) {
   TRACE_EVENT0("audio", "AudioDevice::FireRenderCallback");
 
   size_t num_frames = 0;
   if (callback_) {
     // Update the audio-delay measurement then ask client to render audio.
     num_frames = callback_->Render(audio_data_,
                                    buffer_size_,
                                    audio_delay_milliseconds_);
 
     // Interleave, scale, and clip to int16.
     // TODO(crogers): avoid converting to integer here, and pass the data
     // to the browser process as float, so we don't lose precision for
     // audio hardware which has better than 16bit precision.
     media::InterleaveFloatToInt16(audio_data_,
                                   data,
                                   buffer_size_);
   }
   return num_frames;
 }
 
 void AudioDevice::ShutDownAudioThread() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
 
   if (audio_thread_.get()) {
     // Close the socket to terminate the main thread function in the
     // audio thread.
-    audio_socket_->Close();
-    audio_socket_ = NULL;
+    audio_socket_->Shutdown();  // Stops blocking Receive calls.
     audio_thread_->Join();
     audio_thread_.reset(NULL);
+    audio_socket_.reset();
   }
 }