WebRtcMediaStreamTrackMap added

content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc

Index: content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc b/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bfb7436fef432705207bbdd67c893a142f824e67
--- /dev/null
+++ b/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc
@@ -0,0 +1,139 @@
+// 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_adapter_map.h"
+
+#include <utility>
+
+#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
+
+namespace content {
+
+namespace {
+
+bool RemoveAndDisposeTrackAdapter(
+    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->Dispose();
+  tracks->erase(it);
+  return true;
+}
+
+void DisposeAllTrackAdapters(
+    std::map<std::string, scoped_refptr<WebRtcMediaStreamTrackAdapter>>*
+        tracks) {
+  for (auto& pair : *tracks) {
+    scoped_refptr<WebRtcMediaStreamTrackAdapter>& track = pair.second;
+    DCHECK(track->HasOneRef());
+    track->Dispose();
+  }
+  tracks->clear();
+}
+
+}  // namespace
+
+WebRtcMediaStreamTrackAdapterMap::WebRtcMediaStreamTrackAdapterMap(
+    PeerConnectionDependencyFactory* const factory,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread)
+    : factory_(factory), main_thread_(main_thread) {
+  DCHECK(factory_);
+  DCHECK(main_thread_);
+}
+
+WebRtcMediaStreamTrackAdapterMap::~WebRtcMediaStreamTrackAdapterMap() {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  DisposeAllTrackAdapters();
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackAdapterMap::GetLocalTrackAdapter(
+    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>
+WebRtcMediaStreamTrackAdapterMap::GetOrCreateLocalTrackAdapter(
+    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 WebRtcMediaStreamTrackAdapterMap::DisposeLocalTrackAdapter(
+    const std::string& id) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  base::AutoLock cs(lock_);

[Guido Urdaneta, 2017/05/30 09:02:41]

what does cs mean? (no action necessary, unless it's the initials of your cat's
name).

[hbos_chromium, 2017/06/02 08:52:19]

Critical section or scope, inspired by rtc::CritScope. I thought lock(lock_) was
a bit silly but maybe not :) I'll change it to scoped_lock, that's a common
occurrence for this class, along with lock and auto_lock.

+  return RemoveAndDisposeTrackAdapter(&local_tracks_, id);
+}
+
+size_t WebRtcMediaStreamTrackAdapterMap::GetLocalTrackCount() const {
+  base::AutoLock cs(lock_);
+  return local_tracks_.size();
+}
+
+scoped_refptr<WebRtcMediaStreamTrackAdapter>
+WebRtcMediaStreamTrackAdapterMap::GetRemoteTrackAdapter(
+    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>
+WebRtcMediaStreamTrackAdapterMap::GetOrCreateRemoteTrackAdapter(
+    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 WebRtcMediaStreamTrackAdapterMap::DisposeRemoteTrackAdapter(
+    const std::string& id) {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  base::AutoLock cs(lock_);
+  return RemoveAndDisposeTrackAdapter(&remote_tracks_, id);
+}
+
+size_t WebRtcMediaStreamTrackAdapterMap::GetRemoteTrackCount() const {
+  base::AutoLock cs(lock_);
+  return remote_tracks_.size();
+}
+
+void WebRtcMediaStreamTrackAdapterMap::DisposeAllTrackAdapters() {
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  base::AutoLock cs(lock_);
+  ::content::DisposeAllTrackAdapters(&local_tracks_);
+  ::content::DisposeAllTrackAdapters(&remote_tracks_);
+}
+
+}  // namespace content