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

content/renderer/media/webrtc_local_audio_renderer.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/webrtc_local_audio_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
@@ skipping 80 matching lines @@
     int source_render_view_id)
     : audio_track_(audio_track),
       source_render_view_id_(source_render_view_id),
       playing_(false) {
   DCHECK(audio_track);
   DVLOG(1) << "WebRtcLocalAudioRenderer::WebRtcLocalAudioRenderer()";
 }
 
 WebRtcLocalAudioRenderer::~WebRtcLocalAudioRenderer() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!sink_);
+  DCHECK(!sink_.get());
   DVLOG(1) << "WebRtcLocalAudioRenderer::~WebRtcLocalAudioRenderer()";
 }
 
 void WebRtcLocalAudioRenderer::Start() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Start()";
   DCHECK(thread_checker_.CalledOnValidThread());
   // Add this class as sink to the audio track to ensure that we receive
   // WebRtcAudioCapturerSink::CaptureData() callbacks for captured audio.
   // |audio_params_| will be updated right after the AddCapturerAudioTrack().
   audio_track_->AddSink(this);
 
   base::AutoLock auto_lock(thread_lock_);
-  DCHECK(!sink_);
+  DCHECK(!sink_.get());
 
   // TODO(henrika): we could add a more dynamic solution here but I prefer
   // a fixed size combined with bad audio at overflow. The alternative is
   // that we start to build up latency and that can be more difficult to
   // detect. Tests have shown that the FIFO never contains more than 2 or 3
   // audio frames but I have selected a max size of ten buffers just
   // in case since these tests were performed on a 16 core, 64GB Win 7
   // machine. We could also add some sort of error notifier in this area if
   // the FIFO overflows.
   DCHECK(!loopback_fifo_);
@@ skipping 17 matching lines @@
   sink_->Start();
 
   last_render_time_ = base::Time::Now();
   playing_ = false;
 }
 
 void WebRtcLocalAudioRenderer::Stop() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Stop()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!sink_)
+  if (!sink_.get())
     return;
 
   {
     base::AutoLock auto_lock(thread_lock_);
     playing_ = false;
 
     if (loopback_fifo_.get() != NULL) {
       loopback_fifo_->Clear();
       loopback_fifo_.reset();
     }
   }
 
   // Stop the output audio stream, i.e, stop asking for data to render.
   sink_->Stop();
   sink_ = NULL;
 
   // Ensure that the capturer stops feeding us with captured audio.
   // Note that, we do not stop the capturer here since it may still be used by
   // the WebRTC ADM.
   audio_track_->RemoveSink(this);
   audio_track_ = NULL;
 }
 
 void WebRtcLocalAudioRenderer::Play() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Play()";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(thread_lock_);
 
-  if (!sink_)
+  if (!sink_.get())
     return;
 
   // Resumes rendering by ensuring that WebRtcLocalAudioRenderer::Render()
   // now reads data from the local FIFO.
   playing_ = true;
   last_render_time_ = base::Time::Now();
 
   if (loopback_fifo_)
     loopback_fifo_->Clear();
 }
 
 void WebRtcLocalAudioRenderer::Pause() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Pause()";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(thread_lock_);
 
-  if (!sink_)
+  if (!sink_.get())
     return;
 
   // Temporarily suspends rendering audio.
   // WebRtcLocalAudioRenderer::Render() will return early during this state
   // and only zeros will be provided to the active sink.
   playing_ = false;
 }
 
 void WebRtcLocalAudioRenderer::SetVolume(float volume) {
   DVLOG(1) << "WebRtcLocalAudioRenderer::SetVolume(" << volume << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(thread_lock_);
-  if (sink_)
+  if (sink_.get())
     sink_->SetVolume(volume);
 }
 
 base::TimeDelta WebRtcLocalAudioRenderer::GetCurrentRenderTime() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(thread_lock_);
-  if (!sink_)
+  if (!sink_.get())
     return base::TimeDelta();
   return total_render_time();
 }
 
 bool WebRtcLocalAudioRenderer::IsLocalRenderer() const {
   return true;
 }
 
 }  // namespace content