RemoteMediaStreamImpl using WebRtcMediaStreamTrackMap.

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 972 matching lines @@
 // signaling thread, so this class takes care of delivering them to an
 // RTCPeerConnectionHandler instance on the main thread.
 // In order to do safe PostTask-ing, the class is reference counted and
 // checks for the existence of the RTCPeerConnectionHandler instance before
 // delivering callbacks on the main thread.
 class RTCPeerConnectionHandler::Observer
     : public base::RefCountedThreadSafe<RTCPeerConnectionHandler::Observer>,
       public PeerConnectionObserver {
  public:
   Observer(const base::WeakPtr<RTCPeerConnectionHandler>& handler)
-      : handler_(handler), main_thread_(base::ThreadTaskRunnerHandle::Get()) {}
+      : handler_(handler),
+        main_thread_(base::ThreadTaskRunnerHandle::Get()),
+        track_adapter_map_(handler_->track_adapter_map_) {
+    DCHECK(track_adapter_map_);
+  }
 
  protected:
   friend class base::RefCountedThreadSafe<RTCPeerConnectionHandler::Observer>;
   virtual ~Observer() {}
 
   void OnSignalingChange(
       PeerConnectionInterface::SignalingState new_state) override {
     if (!main_thread_->BelongsToCurrentThread()) {
       main_thread_->PostTask(FROM_HERE,
           base::Bind(&RTCPeerConnectionHandler::Observer::OnSignalingChange,
               this, new_state));
     } else if (handler_) {
       handler_->OnSignalingChange(new_state);
     }
   }
 
   void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override {
     DCHECK(stream);
     std::unique_ptr<RemoteMediaStreamImpl> remote_stream(
-        new RemoteMediaStreamImpl(main_thread_, stream));
+        new RemoteMediaStreamImpl(main_thread_, track_adapter_map_, stream));
 
     // The webkit object owned by RemoteMediaStreamImpl, will be initialized
     // asynchronously and the posted task will execude after that initialization
     // is done.
     main_thread_->PostTask(FROM_HERE,
         base::Bind(&RTCPeerConnectionHandler::Observer::OnAddStreamImpl,
             this, base::Passed(&remote_stream)));
   }
 
   void OnRemoveStream(
@@ skipping 80 matching lines @@
       int sdp_mline_index, int component, int address_family) {
     if (handler_) {
       handler_->OnIceCandidate(sdp, sdp_mid, sdp_mline_index, component,
           address_family);
     }
   }
 
  private:
   const base::WeakPtr<RTCPeerConnectionHandler> handler_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
+  const scoped_refptr<WebRtcMediaStreamTrackAdapterMap> track_adapter_map_;
 };
 
 RTCPeerConnectionHandler::RTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client,
     PeerConnectionDependencyFactory* dependency_factory)
     : client_(client),
       is_closed_(false),
       dependency_factory_(dependency_factory),
-      track_adapter_map_(new WebRtcMediaStreamTrackAdapterMap(
-          dependency_factory_,
-          base::ThreadTaskRunnerHandle::Get())),
+      track_adapter_map_(
+          new WebRtcMediaStreamTrackAdapterMap(dependency_factory_)),
       weak_factory_(this) {
   CHECK(client_);
   GetPeerConnectionHandlers()->insert(this);
 }
 
 RTCPeerConnectionHandler::~RTCPeerConnectionHandler() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Stop();
 
@@ skipping 988 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