WebRtcMediaStreamTrackMap added

content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.cc

+// 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 {
+
+WebRtcMediaStreamTrackAdapterMap::AdapterEntry::AdapterEntry(
+    const scoped_refptr<WebRtcMediaStreamTrackAdapter>& adapter)
+    : adapter(adapter), ref_count(0) {}
+
+WebRtcMediaStreamTrackAdapterMap::AdapterEntry::AdapterEntry(
+    AdapterEntry&& other)
+    : adapter(other.adapter), ref_count(other.ref_count) {
+  other.adapter = nullptr;
+}
+
+WebRtcMediaStreamTrackAdapterMap::AdapterEntry::~AdapterEntry() {
+  DCHECK(!ref_count);
+  DCHECK(!adapter || !adapter->is_initialized());
+}
+
+WebRtcMediaStreamTrackAdapterMap::AdapterRef::AdapterRef(
+    const scoped_refptr<WebRtcMediaStreamTrackAdapterMap>& map,
+    Type type,
+    const std::map<std::string, AdapterEntry>::iterator& it)
+    : map_(map), type_(type), it_(it) {
+  DCHECK(map_);
+  ++entry()->ref_count;
+}
+
+WebRtcMediaStreamTrackAdapterMap::AdapterRef::~AdapterRef() {
+  DCHECK(map_->main_thread_->BelongsToCurrentThread());
+  base::AutoLock scoped_lock(map_->lock_);
+  if (--entry()->ref_count == 0) {
+    entry()->adapter->Dispose();

[hbos_chromium, 2017/06/02 08:57:13]

Since references are only decreased on the main thread I don't need the lock to
do --ref_count, and std::map iterators not being invalidated by the insertion or
removal of other elements, I could probably move the scoped_lock to before doing
erase.

+    if (type_ == Type::kLocal)
+      map_->local_track_adapters_.erase(it_);
+    else
+      map_->remote_track_adapters_.erase(it_);
+  }
+}
+
+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(local_track_adapters_.empty());
+  DCHECK(remote_track_adapters_.empty());
+}
+
+std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
+WebRtcMediaStreamTrackAdapterMap::GetLocalTrackAdapter(const std::string& id) {
+  base::AutoLock scoped_lock(lock_);
+  auto it = local_track_adapters_.find(id);
+  if (it == local_track_adapters_.end())
+    return nullptr;
+  return std::unique_ptr<AdapterRef>(
+      new AdapterRef(this, AdapterRef::Type::kLocal, it));
+}
+
+std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
+WebRtcMediaStreamTrackAdapterMap::GetOrCreateLocalTrackAdapter(
+    const blink::WebMediaStreamTrack& web_track) {
+  DCHECK(!web_track.IsNull());
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  std::string id = web_track.Id().Utf8();
+  base::AutoLock scoped_lock(lock_);
+  auto it = local_track_adapters_.find(id);
+  if (it == local_track_adapters_.end()) {
+    scoped_refptr<WebRtcMediaStreamTrackAdapter> adapter =
+        WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter(
+            factory_, main_thread_, web_track);
+    it = local_track_adapters_.insert(std::make_pair(id, AdapterEntry(adapter)))
+             .first;
+  }
+  return std::unique_ptr<AdapterRef>(
+      new AdapterRef(this, AdapterRef::Type::kLocal, it));
+}
+
+size_t WebRtcMediaStreamTrackAdapterMap::GetLocalTrackCount() const {
+  base::AutoLock scoped_lock(lock_);
+  return local_track_adapters_.size();
+}
+
+std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
+WebRtcMediaStreamTrackAdapterMap::GetRemoteTrackAdapter(const std::string& id) {
+  base::AutoLock scoped_lock(lock_);
+  auto it = remote_track_adapters_.find(id);
+  if (it == remote_track_adapters_.end())
+    return nullptr;
+  return std::unique_ptr<AdapterRef>(
+      new AdapterRef(this, AdapterRef::Type::kRemote, it));
+}
+
+std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
+WebRtcMediaStreamTrackAdapterMap::GetOrCreateRemoteTrackAdapter(
+    webrtc::MediaStreamTrackInterface* webrtc_track) {
+  DCHECK(webrtc_track);
+  DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread());
+  std::string id = webrtc_track->id();
+  base::AutoLock scoped_lock(lock_);
+  auto it = remote_track_adapters_.find(id);
+  if (it == remote_track_adapters_.end()) {
+    scoped_refptr<WebRtcMediaStreamTrackAdapter> adapter =
+        WebRtcMediaStreamTrackAdapter::CreateRemoteTrackAdapter(
+            factory_, main_thread_, webrtc_track);
+    it =
+        remote_track_adapters_.insert(std::make_pair(id, AdapterEntry(adapter)))
+            .first;
+  }
+  return std::unique_ptr<AdapterRef>(
+      new AdapterRef(this, AdapterRef::Type::kRemote, it));
+}
+
+size_t WebRtcMediaStreamTrackAdapterMap::GetRemoteTrackCount() const {
+  base::AutoLock scoped_lock(lock_);
+  return remote_track_adapters_.size();
+}
+
+}  // namespace content