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

content/renderer/media/webrtc_audio_capturer.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_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 216 matching lines @@
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
     float sample_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
            << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
   scoped_refptr<ConfiguredBuffer> current_buffer;
   {
     base::AutoLock auto_lock(lock_);
-    if (source_ == source)
+    if (source_.get() == source.get())
       return;
 
     source_.swap(old_source);
     source_ = source;
     current_buffer = buffer_;
 
     // Reset the flag to allow calling Start() for the new source.
     running_ = false;
   }
 
-  const bool no_default_audio_source_exists = !current_buffer;
+  const bool no_default_audio_source_exists = !current_buffer.get();
 
   // Detach the old source from normal recording or perform first-time
   // initialization if Initialize() has never been called. For the second
   // case, the caller is not "taking over an ongoing session" but instead
   // "taking control over a new session".
-  if (old_source || no_default_audio_source_exists) {
+  if (old_source.get() || no_default_audio_source_exists) {
     DVLOG(1) << "New capture source will now be utilized.";
-    if (old_source)
+    if (old_source.get())
       old_source->Stop();
 
     // Dispatch the new parameters both to the sink(s) and to the new source.
     // The idea is to get rid of any dependency of the microphone parameters
     // which would normally be used by default.
     if (!Reconfigure(sample_rate, channel_layout)) {
       return;
     } else {
       // The buffer has been reconfigured.  Update |current_buffer|.
       base::AutoLock auto_lock(lock_);
       current_buffer = buffer_;
     }
   }
 
-  if (source) {
+  if (source.get()) {
     // Make sure to grab the new parameters in case they were reconfigured.
     source->Initialize(current_buffer->params(), this, session_id_);
   }
 }
 
 void WebRtcAudioCapturer::Start() {
   DVLOG(1) << "WebRtcAudioCapturer::Start()";
   base::AutoLock auto_lock(lock_);
   if (running_)
     return;
 
   // Start the data source, i.e., start capturing data from the current source.
   // Note that, the source does not have to be a microphone.
-  if (source_) {
+  if (source_.get()) {
     // We need to set the AGC control before starting the stream.
     source_->SetAutomaticGainControl(agc_is_enabled_);
     source_->Start();
   }
 
   running_ = true;
 }
 
 void WebRtcAudioCapturer::Stop() {
   DVLOG(1) << "WebRtcAudioCapturer::Stop()";
   scoped_refptr<media::AudioCapturerSource> source;
   {
     base::AutoLock auto_lock(lock_);
     if (!running_)
       return;
 
     source = source_;
     running_ = false;
   }
 
-  if (source)
+  if (source.get())
     source->Stop();
 }
 
 void WebRtcAudioCapturer::SetVolume(double volume) {
   DVLOG(1) << "WebRtcAudioCapturer::SetVolume()";
   base::AutoLock auto_lock(lock_);
-  if (source_)
+  if (source_.get())
     source_->SetVolume(volume);
 }
 
 void WebRtcAudioCapturer::SetAutomaticGainControl(bool enable) {
   base::AutoLock auto_lock(lock_);
   // Store the setting since SetAutomaticGainControl() can be called before
   // Initialize(), in this case stored setting will be applied in Start().
   agc_is_enabled_ = enable;
 
-  if (source_)
+  if (source_.get())
     source_->SetAutomaticGainControl(enable);
 }
 
 void WebRtcAudioCapturer::Capture(media::AudioBus* audio_source,
                                   int audio_delay_milliseconds,
                                   double volume) {
   // This callback is driven by AudioInputDevice::AudioThreadCallback if
   // |source_| is AudioInputDevice, otherwise it is driven by client's
   // CaptureCallback.
   TrackList tracks;
@@ skipping 33 matching lines @@
 }
 
 media::AudioParameters WebRtcAudioCapturer::audio_parameters() const {
   base::AutoLock auto_lock(lock_);
   // |buffer_| can be NULL when SetCapturerSource() or Initialize() has not
   // been called.
   return buffer_.get() ? buffer_->params() : media::AudioParameters();
 }
 
 }  // namespace content