RefCounted types should not have public destructors, content/browser part 2

content/renderer/media/audio_input_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_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
@@ skipping 34 matching lines @@
       callback_(callback),
       event_handler_(event_handler),
       volume_(1.0),
       stream_id_(0),
       session_id_(0),
       pending_device_ready_(false),
       agc_is_enabled_(false) {
   filter_ = RenderThreadImpl::current()->audio_input_message_filter();
 }
 
-AudioInputDevice::~AudioInputDevice() {
-  // TODO(henrika): The current design requires that the user calls
-  // Stop before deleting this class.
-  CHECK_EQ(0, stream_id_);
+void AudioInputDevice::SetDevice(int session_id) {
+  DVLOG(1) << "SetDevice (session_id=" << session_id << ")";
+  message_loop()->PostTask(FROM_HERE,
+      base::Bind(&AudioInputDevice::SetSessionIdOnIOThread, this, session_id));
 }
 
 void AudioInputDevice::Start() {
   DVLOG(1) << "Start()";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::InitializeOnIOThread, this));
 }
 
-void AudioInputDevice::SetDevice(int session_id) {
-  DVLOG(1) << "SetDevice (session_id=" << session_id << ")";
-  message_loop()->PostTask(FROM_HERE,
-      base::Bind(&AudioInputDevice::SetSessionIdOnIOThread, this, session_id));
-}
-
 void AudioInputDevice::Stop() {
   DVLOG(1) << "Stop()";
 
   {
     base::AutoLock auto_lock(audio_thread_lock_);
     audio_thread_.Stop(MessageLoop::current());
   }
 
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::ShutDownOnIOThread, this));
@@ skipping 14 matching lines @@
   return false;
 }
 
 void AudioInputDevice::SetAutomaticGainControl(bool enabled) {
   DVLOG(1) << "SetAutomaticGainControl(enabled=" << enabled << ")";
   message_loop()->PostTask(FROM_HERE,
       base::Bind(&AudioInputDevice::SetAutomaticGainControlOnIOThread,
           this, enabled));
 }
 
-void AudioInputDevice::InitializeOnIOThread() {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  // Make sure we don't call Start() more than once.
-  DCHECK_EQ(0, stream_id_);
-  if (stream_id_)
-    return;
-
-  stream_id_ = filter_->AddDelegate(this);
-  // If |session_id_| is not specified, it will directly create the stream;
-  // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
-  // and create the stream when getting a OnDeviceReady() callback.
-  if (!session_id_) {
-    Send(new AudioInputHostMsg_CreateStream(
-        stream_id_, audio_parameters_,
-        media::AudioManagerBase::kDefaultDeviceId,
-        agc_is_enabled_));
-  } else {
-    Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
-    pending_device_ready_ = true;
-  }
-}
-
-void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  session_id_ = session_id;
-}
-
-void AudioInputDevice::StartOnIOThread() {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_)
-    Send(new AudioInputHostMsg_RecordStream(stream_id_));
-}
-
-void AudioInputDevice::ShutDownOnIOThread() {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  // NOTE: |completion| may be NULL.
-  // Make sure we don't call shutdown more than once.
-  if (stream_id_) {
-    filter_->RemoveDelegate(stream_id_);
-    Send(new AudioInputHostMsg_CloseStream(stream_id_));
-
-    stream_id_ = 0;
-    session_id_ = 0;
-    pending_device_ready_ = false;
-    agc_is_enabled_ = false;
-  }
-
-  // We can run into an issue where ShutDownOnIOThread is called right after
-  // OnStreamCreated is called in cases where Start/Stop are called before we
-  // get the OnStreamCreated callback.  To handle that corner case, we call
-  // Stop(). In most cases, the thread will already be stopped.
-  // Another situation is when the IO thread goes away before Stop() is called
-  // in which case, we cannot use the message loop to close the thread handle
-  // and can't not rely on the main thread existing either.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  audio_thread_.Stop(NULL);
-  audio_callback_.reset();
-}
-
-void AudioInputDevice::SetVolumeOnIOThread(double volume) {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  if (stream_id_)
-    Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
-}
-
-void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
-  DCHECK(message_loop()->BelongsToCurrentThread());
-  DCHECK_EQ(0, stream_id_) <<
-      "The AGC state can not be modified while capturing is active.";
-  if (stream_id_)
-    return;
-
-  // We simply store the new AGC setting here. This value will be used when
-  // a new stream is initialized and by GetAutomaticGainControl().
-  agc_is_enabled_ = enabled;
-}
-
 void AudioInputDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
   DCHECK(message_loop()->BelongsToCurrentThread());
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
@@ skipping 86 matching lines @@
     Send(new AudioInputHostMsg_CreateStream(stream_id_, audio_parameters_,
                                             device_id, agc_is_enabled_));
   }
 
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
     event_handler_->OnDeviceStarted(device_id);
 }
 
+AudioInputDevice::~AudioInputDevice() {
+  // TODO(henrika): The current design requires that the user calls
+  // Stop before deleting this class.
+  CHECK_EQ(0, stream_id_);
+}
+
+void AudioInputDevice::InitializeOnIOThread() {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  // Make sure we don't call Start() more than once.
+  DCHECK_EQ(0, stream_id_);
+  if (stream_id_)
+    return;
+
+  stream_id_ = filter_->AddDelegate(this);
+  // If |session_id_| is not specified, it will directly create the stream;
+  // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
+  // and create the stream when getting a OnDeviceReady() callback.
+  if (!session_id_) {
+    Send(new AudioInputHostMsg_CreateStream(
+        stream_id_, audio_parameters_,
+        media::AudioManagerBase::kDefaultDeviceId,
+        agc_is_enabled_));
+  } else {
+    Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
+    pending_device_ready_ = true;
+  }
+}
+
+void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  session_id_ = session_id;
+}
+
+void AudioInputDevice::StartOnIOThread() {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  if (stream_id_)
+    Send(new AudioInputHostMsg_RecordStream(stream_id_));
+}
+
+void AudioInputDevice::ShutDownOnIOThread() {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  // NOTE: |completion| may be NULL.
+  // Make sure we don't call shutdown more than once.
+  if (stream_id_) {
+    filter_->RemoveDelegate(stream_id_);
+    Send(new AudioInputHostMsg_CloseStream(stream_id_));
+
+    stream_id_ = 0;
+    session_id_ = 0;
+    pending_device_ready_ = false;
+    agc_is_enabled_ = false;
+  }
+
+  // We can run into an issue where ShutDownOnIOThread is called right after
+  // OnStreamCreated is called in cases where Start/Stop are called before we
+  // get the OnStreamCreated callback.  To handle that corner case, we call
+  // Stop(). In most cases, the thread will already be stopped.
+  // Another situation is when the IO thread goes away before Stop() is called
+  // in which case, we cannot use the message loop to close the thread handle
+  // and can't not rely on the main thread existing either.
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  audio_thread_.Stop(NULL);
+  audio_callback_.reset();
+}
+
+void AudioInputDevice::SetVolumeOnIOThread(double volume) {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  if (stream_id_)
+    Send(new AudioInputHostMsg_SetVolume(stream_id_, volume));
+}
+
+void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
+  DCHECK(message_loop()->BelongsToCurrentThread());
+  DCHECK_EQ(0, stream_id_) <<
+      "The AGC state can not be modified while capturing is active.";
+  if (stream_id_)
+    return;
+
+  // We simply store the new AGC setting here. This value will be used when
+  // a new stream is initialized and by GetAutomaticGainControl().
+  agc_is_enabled_ = enabled;
+}
+
 void AudioInputDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the input device has been stopped";
   ShutDownOnIOThread();
 }
 
 // AudioInputDevice::AudioThreadCallback
@@ skipping 38 matching lines @@
                                     channel_index,
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   capture_callback_->Capture(audio_data_, number_of_frames,
                              audio_delay_milliseconds, volume);
 }