Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright 2013 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/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 202 matching lines @@
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::Init() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::Init()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (initialized_)
     return 0;
 
-  DCHECK(!capturer_);
+  DCHECK(!capturer_.get());
   capturer_ = WebRtcAudioCapturer::CreateCapturer();
   // Add itself as an audio track to the |capturer_|. This is because WebRTC
   // supports only one ADM but multiple audio tracks, so the ADM can't be the
   // sink of certain audio track now.
   // TODO(xians): Register the ADM as the sink of the audio track if WebRTC
   // supports one ADM for each audio track.
-  if (capturer_)
+  if (capturer_.get())
     capturer_->AddSink(this);
 
   // We need to return a success to continue the initialization of WebRtc VoE
   // because failure on the capturer_ initialization should not prevent WebRTC
   // from working. See issue http://crbug.com/144421 for details.
   initialized_ = true;
 
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::Terminate() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::Terminate()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Calling Terminate() multiple times in a row is OK.
   if (!initialized_)
     return 0;
 
   StopRecording();
   StopPlayout();
 
   // It is necessary to stop the |renderer_| before going away.
-  if (renderer_) {
+  if (renderer_.get()) {
     // Grab a local reference while we call Stop(), which will trigger a call to
     // RemoveAudioRenderer that clears our reference to the audio renderer.
     scoped_refptr<WebRtcAudioRenderer> local_renderer(renderer_);
     local_renderer->Stop();
-    DCHECK(!renderer_);
+    DCHECK(!renderer_.get());
   }
 
-  if (capturer_) {
+  if (capturer_.get()) {
     // |capturer_| is stopped by the media stream, so do not need to
     // call Stop() here.
     capturer_->RemoveSink(this);
     capturer_ = NULL;
   }
 
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   return initialized_;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutIsAvailable(bool* available) {
   *available = initialized_;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::PlayoutIsInitialized() const {
   return initialized_;
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingIsAvailable(bool* available) {
-  *available = (capturer_ != NULL);
+  *available = (capturer_.get() != NULL);
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::RecordingIsInitialized() const {
   DVLOG(1) << "WebRtcAudioDeviceImpl::RecordingIsInitialized()";
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (capturer_ != NULL);
+  return (capturer_.get() != NULL);
 }
 
 int32_t WebRtcAudioDeviceImpl::StartPlayout() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::StartPlayout()";
   LOG_IF(ERROR, !audio_transport_callback_) << "Audio transport is missing";
   {
     base::AutoLock auto_lock(lock_);
     if (!audio_transport_callback_)
       return 0;
   }
@@ skipping 75 matching lines @@
   DVLOG(1) <<  "WebRtcAudioDeviceImpl::SetAGC(enable=" << enable << ")";
   DCHECK(initialized_);
 
   // Return early if we are not changing the AGC state.
   if (enable == agc_is_enabled_)
     return 0;
 
   // The current implementation does not support changing the AGC state while
   // recording. Using this approach simplifies the design and it is also
   // inline with the  latest WebRTC standard.
-  if (!capturer_ || capturer_->is_recording())
+  if (!capturer_.get() || capturer_->is_recording())
     return -1;
 
   capturer_->SetAutomaticGainControl(enable);
   agc_is_enabled_ = enable;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::AGC() const {
   DVLOG(1) << "WebRtcAudioDeviceImpl::AGC()";
   DCHECK(thread_checker_.CalledOnValidThread());
   // To reduce the usage of IPC messages, an internal AGC state is used.
   // TODO(henrika): investigate if there is a need for a "deeper" getter.
   return agc_is_enabled_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetMicrophoneVolume(uint32_t volume) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::SetMicrophoneVolume(" << volume << ")";
   DCHECK(initialized_);
-  if (!capturer_)
+  if (!capturer_.get())
     return -1;
 
   if (volume > kMaxVolumeLevel)
     return -1;
 
   // WebRTC uses a range of [0, 255] to represent the level of the microphone
   // volume. The IPC channel between the renderer and browser process works
   // with doubles in the [0.0, 1.0] range and we have to compensate for that.
   double normalized_volume = static_cast<double>(volume) / kMaxVolumeLevel;
   capturer_->SetVolume(normalized_volume);
   return 0;
 }
 
 // TODO(henrika): sort out calling thread once we start using this API.
 int32_t WebRtcAudioDeviceImpl::MicrophoneVolume(uint32_t* volume) const {
   DVLOG(1) << "WebRtcAudioDeviceImpl::MicrophoneVolume()";
   // The microphone level is fed to this class using the Capture() callback
   // and cached in the same method, i.e. we don't ask the native audio layer
   // for the actual micropone level here.
   DCHECK(initialized_);
-  if (!capturer_)
+  if (!capturer_.get())
     return -1;
   base::AutoLock auto_lock(lock_);
   *volume = microphone_volume_;
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::MaxMicrophoneVolume(uint32_t* max_volume) const {
   *max_volume = kMaxVolumeLevel;
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::MinMicrophoneVolume(uint32_t* min_volume) const {
   *min_volume = 0;
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoPlayoutIsAvailable(bool* available) const {
   DCHECK(initialized_);
   *available = (output_channels() == 2);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoRecordingIsAvailable(
     bool* available) const {
   DCHECK(initialized_);
-  if (!capturer_)
+  if (!capturer_.get())
     return -1;
   *available = (input_channels() == 2);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutDelay(uint16_t* delay_ms) const {
   base::AutoLock auto_lock(lock_);
   *delay_ms = static_cast<uint16_t>(output_delay_ms_);
   return 0;
 }
@@ skipping 14 matching lines @@
     uint32_t* samples_per_sec) const {
   *samples_per_sec = static_cast<uint32_t>(output_sample_rate());
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::SetAudioRenderer(WebRtcAudioRenderer* renderer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(renderer);
 
   base::AutoLock auto_lock(lock_);
-  if (renderer_)
+  if (renderer_.get())
     return false;
 
   if (!renderer->Initialize(this))
     return false;
 
   renderer_ = renderer;
   return true;
 }
 
 }  // namespace content