WebRtcMediaStreamTrackMap added

content/renderer/media/webrtc/webrtc_media_stream_track_collection.cc

Index: content/renderer/media/webrtc/webrtc_media_stream_track_collection.cc
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_track_collection.cc b/content/renderer/media/webrtc/webrtc_media_stream_track_collection.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8b96f14fc5912162901ff61b0aff6121e4315376
--- /dev/null
+++ b/content/renderer/media/webrtc/webrtc_media_stream_track_collection.cc
@@ -0,0 +1,136 @@
+// Copyright (c) 2017 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/webrtc_media_stream_track_collection.h"
+
+#include <utility>
+
+#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
+
+namespace content {
+
+namespace {
+
+bool RemoveAndUninitializeTrack(
+    std::map<std::string, scoped_refptr<WebRtcMediaStreamTrackAdapter>>* tracks,
+    const std::string& id) {
+  auto it = tracks->find(id);
+  if (it == tracks->end())
+    return false;
+  scoped_refptr<WebRtcMediaStreamTrackAdapter>& track = it->second;
+  DCHECK(track->HasOneRef());
+  track->Uninitialize();
+  tracks->erase(it);
+  return true;
+}
+
+void ClearAndUninitializeTracks(
+    std::map<std::string, scoped_refptr<WebRtcMediaStreamTrackAdapter>>*
+        tracks) {
+  for (auto& pair : *tracks) {
+    scoped_refptr<WebRtcMediaStreamTrackAdapter>& track = pair.second;
+    DCHECK(track->HasOneRef());
+    track->Uninitialize();
+  }
+  tracks->clear();
+}
+
+}  // namespace
+
+WebRtcMediaStreamTrackCollection::WebRtcMediaStreamTrackCollection(
+    PeerConnectionDependencyFactory* const factory,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread)
+    : factory_(factory), main_thread_(main_thread) {
+  DCHECK(factory_);
+  DCHECK(main_thread_);
+}
+
+WebRtcMediaStreamTrackCollection::~WebRtcMediaStreamTrackCollection() {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  ClearAndUninitializeTracks();
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackCollection::GetLocalTrack(const std::string& id) const {
+  base::AutoLock cs(lock_);
+  auto it = local_tracks_.find(id);
+  if (it == local_tracks_.end())
+    return nullptr;
+  return it->second;
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackCollection::GetOrCreateLocalTrack(
+    const blink::WebMediaStreamTrack& web_track) {
+  DCHECK(!web_track.IsNull());
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  std::string id = web_track.Id().Utf8();
+  base::AutoLock cs(lock_);
+  auto it = local_tracks_.find(id);
+  if (it != local_tracks_.end())
+    return it->second;
+  scoped_refptr<WebRtcMediaStreamTrackAdapter> track =
+      WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
+          factory_, main_thread_, web_track);
+  local_tracks_.insert(std::make_pair(id, track));
+  return track;
+}
+
+bool WebRtcMediaStreamTrackCollection::RemoveAndUninitializeLocalTrack(
+    const std::string& id) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  base::AutoLock cs(lock_);
+  return RemoveAndUninitializeTrack(&local_tracks_, id);
+}
+
+size_t WebRtcMediaStreamTrackCollection::GetLocalTrackCount() const {
+  base::AutoLock cs(lock_);
+  return local_tracks_.size();
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackCollection::GetRemoteTrack(const std::string& id) const {
+  base::AutoLock cs(lock_);
+  auto it = remote_tracks_.find(id);
+  if (it == remote_tracks_.end())
+    return nullptr;
+  return it->second;
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackCollection::GetOrCreateRemoteTrack(
+    webrtc::MediaStreamTrackInterface* webrtc_track) {
+  DCHECK(webrtc_track);
+  DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  std::string id = webrtc_track->id();
+  base::AutoLock cs(lock_);
+  auto it = remote_tracks_.find(id);
+  if (it != remote_tracks_.end())
+    return it->second;
+  scoped_refptr<WebRtcMediaStreamTrackAdapter> track =
+      WebRtcMediaStreamTrackAdapter::CreateRemoteTrackAdapter(
+          factory_, main_thread_, webrtc_track);
+  remote_tracks_.insert(std::make_pair(id, track));
+  return track;
+}
+
+bool WebRtcMediaStreamTrackCollection::RemoveAndUninitializeRemoteTrack(
+    const std::string& id) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  base::AutoLock cs(lock_);
+  return RemoveAndUninitializeTrack(&remote_tracks_, id);
+}
+
+size_t WebRtcMediaStreamTrackCollection::GetRemoteTrackCount() const {
+  base::AutoLock cs(lock_);
+  return remote_tracks_.size();
+}
+
+void WebRtcMediaStreamTrackCollection::ClearAndUninitializeTracks() {
+  DCHECK(main_thread_->BelongsToCurrentThread());

[Guido Urdaneta, 2017/05/22 16:14:44]

Does this need to acquire the lock?

[hbos_chromium, 2017/05/29 13:28:50]

Nice catch, done.

+  ::content::ClearAndUninitializeTracks(&local_tracks_);
+  ::content::ClearAndUninitializeTracks(&remote_tracks_);
+}
+
+}  // namespace content