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

content/renderer/media/media_stream_dependency_factory.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/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 95 matching lines @@
       config.relay_server = turn_configurations[0].server.hostname();
       config.relay_server_port = turn_configurations[0].server.port();
       config.relay_username = turn_configurations[0].username;
       config.relay_password = turn_configurations[0].password;
       // Use the turn server as the stun server.
       config.stun_server = config.relay_server;
       config.stun_server_port = config.relay_server_port;
     }
 
     return new P2PPortAllocator(web_frame_,
-                                socket_dispatcher_,
+                                socket_dispatcher_.get(),
                                 network_manager_,
                                 socket_factory_,
                                 config);
   }
 
  protected:
   virtual ~P2PPortAllocatorFactory() {}
 
  private:
   scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
@@ skipping 197 matching lines @@
     WebKit::WebMediaStream* description) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
     DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
     return;
   }
 
   std::string label = UTF16ToUTF8(description->label());
   scoped_refptr<webrtc::MediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
-  MediaStreamExtraData* extra_data = new MediaStreamExtraData(native_stream,
-                                                              true);
+  MediaStreamExtraData* extra_data =
+      new MediaStreamExtraData(native_stream.get(), true);
   description->setExtraData(extra_data);
 
   // Add audio tracks.
   WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
   description->audioTracks(audio_tracks);
   for (size_t i = 0; i < audio_tracks.size(); ++i) {
     AddNativeMediaStreamTrack(*description, audio_tracks[i]);
   }
 
   // Add video tracks.
@@ skipping 12 matching lines @@
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(description->extraData());
   extra_data->SetLocalStreamStopCallback(stream_stop);
 }
 
 bool MediaStreamDependencyFactory::AddNativeMediaStreamTrack(
       const WebKit::WebMediaStream& stream,
       const WebKit::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(stream.extraData());
-  webrtc::MediaStreamInterface* native_stream = extra_data->stream();
+  webrtc::MediaStreamInterface* native_stream = extra_data->stream().get();
   DCHECK(native_stream);
 
   WebKit::WebMediaStreamSource source = track.source();
   MediaStreamSourceExtraData* source_data =
       static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
       // TODO(crogers, xians): In reality we should be able to send a unique
@@ skipping 21 matching lines @@
          type == WebKit::WebMediaStreamSource::TypeVideo);
 
   std::string track_id = UTF16ToUTF8(track.id());
   if (source.type() == WebKit::WebMediaStreamSource::TypeAudio) {
     // TODO(henrika,xians): Refactor how an audio track is created to harmonize
     // with video tracks.
     scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         CreateLocalAudioTrack(track_id, source_data->local_audio_source()));
     audio_track->set_enabled(track.isEnabled());
     if (GetWebRtcAudioDevice()) {
-      WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+      WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer().get();
       if (!capturer->is_recording())
         capturer->Start();
     }
-    return native_stream->AddTrack(audio_track);
+    return native_stream->AddTrack(audio_track.get());
   } else {
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         CreateLocalVideoTrack(track_id, source_data->video_source()));
     video_track->set_enabled(track.isEnabled());
-    return native_stream->AddTrack(video_track);
+    return native_stream->AddTrack(video_track.get());
   }
 }
 
 bool MediaStreamDependencyFactory::AddNativeVideoMediaTrack(
     const std::string& track_id,
     WebKit::WebMediaStream* stream,
     cricket::VideoCapturer* capturer) {
   if (!stream) {
     LOG(ERROR) << "AddNativeVideoMediaTrack called with null WebMediaStream.";
     return false;
   }
 
   // Create native track from the source.
   scoped_refptr<webrtc::VideoTrackInterface> native_track =
       CreateLocalVideoTrack(track_id, capturer);
 
   // Add the native track to native stream
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream->extraData());
   DCHECK(extra_data);
-  webrtc::MediaStreamInterface* native_stream = extra_data->stream();
-  native_stream->AddTrack(native_track);
+  webrtc::MediaStreamInterface* native_stream = extra_data->stream().get();
+  native_stream->AddTrack(native_track.get());
 
   // Create a new webkit video track.
   WebKit::WebMediaStreamTrack webkit_track;
   WebKit::WebMediaStreamSource webkit_source;
   WebKit::WebString webkit_track_id(UTF8ToUTF16(track_id));
   WebKit::WebMediaStreamSource::Type type =
       WebKit::WebMediaStreamSource::TypeVideo;
   webkit_source.initialize(webkit_track_id, type, webkit_track_id);
   webkit_track.initialize(webkit_track_id, webkit_source);
 
   // Add the track to WebMediaStream.
   stream->addTrack(webkit_track);
   return true;
 }
 
 bool MediaStreamDependencyFactory::RemoveNativeMediaStreamTrack(
     const WebKit::WebMediaStream& stream,
     const WebKit::WebMediaStreamTrack& track) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
-  webrtc::MediaStreamInterface* native_stream = extra_data->stream();
+  webrtc::MediaStreamInterface* native_stream = extra_data->stream().get();
   DCHECK(native_stream);
 
   WebKit::WebMediaStreamSource::Type type = track.source().type();
   DCHECK(type == WebKit::WebMediaStreamSource::TypeAudio ||
          type == WebKit::WebMediaStreamSource::TypeVideo);
 
   std::string track_id = UTF16ToUTF8(track.id());
   return type == WebKit::WebMediaStreamSource::TypeAudio ?
       native_stream->RemoveTrack(native_stream->FindAudioTrack(track_id)) :
       native_stream->RemoveTrack(native_stream->FindVideoTrack(track_id));
 }
 
 bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
-  if (!pc_factory_) {
-    DCHECK(!audio_device_);
+  if (!pc_factory_.get()) {
+    DCHECK(!audio_device_.get());
     audio_device_ = new WebRtcAudioDeviceImpl();
     scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
-        webrtc::CreatePeerConnectionFactory(
-            worker_thread_, signaling_thread_, audio_device_, NULL, NULL));
-    if (factory)
+        webrtc::CreatePeerConnectionFactory(worker_thread_,
+                                            signaling_thread_,
+                                            audio_device_.get(),
+                                            NULL,
+                                            NULL));
+    if (factory.get())
       pc_factory_ = factory;
     else
       audio_device_ = NULL;
   }
   return pc_factory_.get() != NULL;
 }
 
 bool MediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
@@ skipping 20 matching lines @@
             url));
   }
 
   scoped_refptr<P2PPortAllocatorFactory> pa_factory =
         new talk_base::RefCountedObject<P2PPortAllocatorFactory>(
             p2p_socket_dispatcher_.get(),
             network_manager_,
             socket_factory_.get(),
             web_frame);
   return pc_factory_->CreatePeerConnection(
-      ice_servers, constraints, pa_factory, observer).get();
+                          ice_servers, constraints, pa_factory.get(), observer)
+      .get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 MediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return pc_factory_->CreateLocalMediaStream(label).get();
 }
 
 scoped_refptr<webrtc::AudioSourceInterface>
 MediaStreamDependencyFactory::CreateLocalAudioSource(
@@ skipping 22 matching lines @@
     const StreamDeviceInfo& device_info) {
   DVLOG(1) << "MediaStreamDependencyFactory::InitializeAudioSource()";
 
   // TODO(henrika): the current design does not support a unique source
   // for each audio track.
   if (device_info.session_id <= 0)
     return false;
 
   // Initialize the source using audio parameters for the selected
   // capture device.
-  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer().get();
   // TODO(henrika): refactor \content\public\common\media_stream_request.h
   // to allow dependency of media::ChannelLayout and avoid static_cast.
   if (!capturer->Initialize(
           render_view_id,
           static_cast<media::ChannelLayout>(device_info.device.channel_layout),
           device_info.device.sample_rate, device_info.session_id))
     return false;
 
   return true;
 }
 
 bool MediaStreamDependencyFactory::CreateWebAudioSource(
     WebKit::WebMediaStreamSource* source) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
   DCHECK(GetWebRtcAudioDevice());
 
   // WebAudio needs the WebRtcAudioCapturer to be able to send its data
   // over a PeerConnection. The microphone source is not utilized in this
   // case; instead the WebRtcAudioCapturer is driving.
-  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer();
+  WebRtcAudioCapturer* capturer = GetWebRtcAudioDevice()->capturer().get();
   if (!capturer)
     return false;
 
   // Set up the source and ensure that WebAudio is driving things instead of
   // a microphone.
 
   scoped_refptr<WebAudioCapturerSource>
       webaudio_capturer_source(new WebAudioCapturerSource(capturer));
   MediaStreamSourceExtraData* source_data =
-      new content::MediaStreamSourceExtraData(webaudio_capturer_source);
+      new content::MediaStreamSourceExtraData(webaudio_capturer_source.get());
 
   // Create a LocalAudioSource object which holds audio options.
   // Use audio constraints where all values are false, i.e., disable
   // echo cancellation, automatic gain control, noise suppression and
   // high-pass filter. SetLocalAudioSource() affects core audio parts in
   // third_party/Libjingle.
   WebAudioConstraints webaudio_audio_constraints_all_false;
   source_data->SetLocalAudioSource(
       CreateLocalAudioSource(&webaudio_audio_constraints_all_false));
   source->setExtraData(source_data);
 
   // Replace the default source with WebAudio as source instead.
-  source->addAudioConsumer(webaudio_capturer_source);
+  source->addAudioConsumer(webaudio_capturer_source.get());
 
   return true;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
   return pc_factory_->CreateVideoTrack(id, source).get();
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& id, cricket::VideoCapturer* capturer) {
   if (!capturer) {
     LOG(ERROR) << "CreateLocalVideoTrack called with null VideoCapturer.";
     return NULL;
   }
 
   // Create video source from the |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       pc_factory_->CreateVideoSource(capturer, NULL).get();
 
   // Create native track from the source.
-  return pc_factory_->CreateVideoTrack(id, source).get();
+  return pc_factory_->CreateVideoTrack(id, source.get()).get();
 }
 
 scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     webrtc::AudioSourceInterface* source) {
   // TODO(xians): Merge |source| to the capturer(). We can't do this today
   // because only one capturer() is supported while one |source| is created
   // for each audio track.
   return WebRtcLocalAudioTrack::Create(id, GetWebRtcAudioDevice()->capturer(),
@@ skipping 10 matching lines @@
 
 webrtc::IceCandidateInterface* MediaStreamDependencyFactory::CreateIceCandidate(
     const std::string& sdp_mid,
     int sdp_mline_index,
     const std::string& sdp) {
   return webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 WebRtcAudioDeviceImpl*
 MediaStreamDependencyFactory::GetWebRtcAudioDevice() {
-  return audio_device_;
+  return audio_device_.get();
 }
 
 void MediaStreamDependencyFactory::StopLocalAudioSource(
     const WebKit::WebMediaStream& description) {
   MediaStreamExtraData* extra_data = static_cast<MediaStreamExtraData*>(
       description.extraData());
-  if (extra_data && extra_data->is_local() && extra_data->stream() &&
+  if (extra_data && extra_data->is_local() && extra_data->stream().get() &&
       !extra_data->stream()->GetAudioTracks().empty()) {
     if (GetWebRtcAudioDevice()) {
       scoped_refptr<WebRtcAudioCapturer> capturer =
           GetWebRtcAudioDevice()->capturer();
-      if (capturer)
+      if (capturer.get())
         capturer->Stop();
     }
   }
 }
 
 void MediaStreamDependencyFactory::InitializeWorkerThread(
     talk_base::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
     base::WaitableEvent* event) {
   DCHECK_EQ(base::MessageLoop::current(), chrome_worker_thread_.message_loop());
-  network_manager_ = new IpcNetworkManager(p2p_socket_dispatcher_);
+  network_manager_ = new IpcNetworkManager(p2p_socket_dispatcher_.get());
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::DeleteIpcNetworkManager() {
   DCHECK_EQ(base::MessageLoop::current(), chrome_worker_thread_.message_loop());
   delete network_manager_;
   network_manager_ = NULL;
 }
 
 bool MediaStreamDependencyFactory::EnsurePeerConnectionFactory() {
@@ skipping 30 matching lines @@
     base::WaitableEvent event(true, false);
     chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
         base::Unretained(this),
         &event));
     event.Wait();
   }
 
   if (!socket_factory_) {
     socket_factory_.reset(
-        new IpcPacketSocketFactory(p2p_socket_dispatcher_));
+        new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
   }
 
   // Init SSL, which will be needed by PeerConnection.
 #if defined(USE_OPENSSL)
   if (!talk_base::InitializeSSL()) {
     LOG(ERROR) << "Failed on InitializeSSL.";
     return false;
   }
 #else
   // TODO(ronghuawu): Replace this call with InitializeSSL.
@@ skipping 20 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content