RTCPeerConnection.ontrack event added.

content/renderer/media/rtc_peer_connection_handler.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/rtc_peer_connection_handler.h"
 
 #include <string.h>
 
 #include <string>
 #include <utility>
@@ skipping 1664 matching lines @@
       webrtc_receivers = native_peer_connection_->GetReceivers();
   std::vector<std::unique_ptr<blink::WebRTCRtpReceiver>> web_receivers;
   for (size_t i = 0; i < webrtc_receivers.size(); ++i) {
     rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track =
         webrtc_receivers[i]->track();
     DCHECK(webrtc_track);
     std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
         track_adapter =
             track_adapter_map_->GetRemoteTrackAdapter(webrtc_track->id());
     DCHECK(track_adapter);
+    DCHECK(track_adapter->is_initialized());
     // Create a reference to the receiver. Multiple |RTCRtpReceiver|s can
     // reference the same webrtc track, see |id|.
     web_receivers.push_back(base::MakeUnique<RTCRtpReceiver>(
         webrtc_receivers[i].get(), std::move(track_adapter)));
   }
 
   // |blink::WebVector|'s size must be known at construction, that is why
   // |web_vectors| uses |std::vector| and needs to be moved before returning.
   blink::WebVector<std::unique_ptr<blink::WebRTCRtpReceiver>> result(
       web_receivers.size());
@@ skipping 249 matching lines @@
   if (peer_connection_tracker_) {
     peer_connection_tracker_->TrackAddStream(
         this, stream_ptr->webkit_stream(),
         PeerConnectionTracker::SOURCE_REMOTE);
   }
 
   PerSessionWebRTCAPIMetrics::GetInstance()->IncrementStreamCounter();
 
   track_metrics_.AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM,
                            stream_ptr->webrtc_stream().get());
-  if (!is_closed_)
-    client_->DidAddRemoteStream(stream_ptr->webkit_stream());
+  if (!is_closed_) {
+    // Get receivers for the tracks in this stream. The result is a subset of
+    // |RTCPeerConnectionHandler::GetReceivers|. We can't invoke that here
+    // because creating receivers for remote streams that have not been
+    // processed on both threads yet might grab track adapters that have not
+    // been initialized yet.
+    // TODO(hbos): Helper function instead of duplicate code!
+    std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>>
+        webrtc_receivers = native_peer_connection_->GetReceivers();
+    std::vector<std::unique_ptr<blink::WebRTCRtpReceiver>> stream_web_receivers;
+    for (auto& webrtc_receiver : webrtc_receivers) {
+      rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track =
+          webrtc_receiver->track();
+      DCHECK(webrtc_track);
+      bool is_stream_receiver = false;
+      if (webrtc_track->kind() ==
+          webrtc::MediaStreamTrackInterface::kAudioKind) {
+        for (const auto& track :
+             stream_ptr->webrtc_stream()->GetAudioTracks()) {
+          if (webrtc_track == track) {
+            is_stream_receiver = true;
+            break;
+          }
+        }
+      } else {
+        for (const auto& track :
+             stream_ptr->webrtc_stream()->GetVideoTracks()) {
+          if (webrtc_track == track) {
+            is_stream_receiver = true;
+            break;
+          }
+        }
+      }
+      if (is_stream_receiver) {
+        std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
+            track_adapter =
+                track_adapter_map_->GetRemoteTrackAdapter(webrtc_track->id());
+        DCHECK(track_adapter);
+        DCHECK(track_adapter->is_initialized());
+        // Create a reference to the receiver. Multiple |RTCRtpReceiver|s can
+        // reference the same webrtc track, see |id|.
+        stream_web_receivers.push_back(base::MakeUnique<RTCRtpReceiver>(
+            webrtc_receiver.get(), std::move(track_adapter)));
+      }
+    }
+    blink::WebVector<std::unique_ptr<blink::WebRTCRtpReceiver>> result(
+        stream_web_receivers.size());
+    for (size_t i = 0; i < stream_web_receivers.size(); ++i) {
+      result[i] = std::move(stream_web_receivers[i]);
+    }
+    client_->DidAddRemoteStream(stream_ptr->webkit_stream(), &result);
+  }
 }
 
 void RTCPeerConnectionHandler::OnRemoveStream(
     const scoped_refptr<webrtc::MediaStreamInterface>& stream) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("webrtc", "RTCPeerConnectionHandler::OnRemoveStreamImpl");
   auto it = remote_streams_.find(stream.get());
   if (it == remote_streams_.end()) {
     NOTREACHED() << "Stream not found";
     return;
@@ skipping 141 matching lines @@
 }
 
 void RTCPeerConnectionHandler::ResetUMAStats() {
   DCHECK(thread_checker_.CalledOnValidThread());
   num_local_candidates_ipv6_ = 0;
   num_local_candidates_ipv4_ = 0;
   ice_connection_checking_start_ = base::TimeTicks();
   memset(ice_state_seen_, 0, sizeof(ice_state_seen_));
 }
 }  // namespace content