Index: content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h |
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h b/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..64a3320f061d531b5d1fa7b13a99d0ae18e9fbab |
--- /dev/null |
+++ b/content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h |
@@ -0,0 +1,145 @@ |
+// 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. |
+ |
+#ifndef CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_MEDIA_STREAM_TRACK_COLLECTION_H_ |
+#define CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_MEDIA_STREAM_TRACK_COLLECTION_H_ |
+ |
+#include <map> |
+#include <string> |
+ |
+#include "base/memory/ref_counted.h" |
+#include "base/single_thread_task_runner.h" |
+#include "content/common/content_export.h" |
+#include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter.h" |
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" |
+#include "third_party/webrtc/api/mediastreaminterface.h" |
+ |
+namespace content { |
+ |
+class PeerConnectionDependencyFactory; |
+ |
+// A map and owner of |WebRtcMediaStreamTrackAdapter|s. It takes care of |
+// creating, initializing and disposing track adapters independently of media |
+// streams. Adapters are accessed via |AdapterRef|s, when all references to an |
+// adapter are destroyed it is disposed and removed from the map. |
+class CONTENT_EXPORT WebRtcMediaStreamTrackAdapterMap |
+ : public base::RefCountedThreadSafe<WebRtcMediaStreamTrackAdapterMap> { |
+ private: |
+ // The map's entries are reference counted in order to |Dispose| the adapter |
+ // when all |AdapterRef|s referencing an entry are destroyed. |
+ // Private section needed here due to |AdapterRef|'s usage of |AdapterEntry|. |
+ struct AdapterEntry { |
+ AdapterEntry(const scoped_refptr<WebRtcMediaStreamTrackAdapter>& adapter); |
+ AdapterEntry(AdapterEntry&& other); |
+ ~AdapterEntry(); |
+ |
+ AdapterEntry(const AdapterEntry&) = delete; |
+ AdapterEntry& operator=(const AdapterEntry&) = delete; |
+ |
+ scoped_refptr<WebRtcMediaStreamTrackAdapter> adapter; |
+ }; |
+ |
+ public: |
+ // Acts as an accessor to adapter members without leaking a reference to the |
+ // adapter. When the last |AdapterRef| is destroyed, the corresponding adapter |
+ // is |Dispose|d and removed from the map. |
+ class CONTENT_EXPORT AdapterRef { |
+ public: |
+ // Must be invoked on the main thread. If this was the last reference to the |
+ // adapter it will be disposed and removed from the map. |
+ ~AdapterRef(); |
+ |
+ bool is_initialized() const { return adapter_->is_initialized(); } |
+ const blink::WebMediaStreamTrack& web_track() const { |
+ return adapter_->web_track(); |
+ } |
+ webrtc::MediaStreamTrackInterface* webrtc_track() const { |
+ return adapter_->webrtc_track(); |
+ } |
+ |
+ // Warning: Holding an external reference to the adapter will prevent |
+ // |~AdapterRef| from disposing the adapter. |
+ WebRtcMediaStreamTrackAdapter* GetAdapterForTesting() const { |
+ return adapter_.get(); |
+ } |
+ |
+ private: |
+ friend class WebRtcMediaStreamTrackAdapterMap; |
+ |
+ using MapEntryIterator = std::map<std::string, AdapterEntry>::iterator; |
+ enum class Type { kLocal, kRemote }; |
+ |
+ // Increments the |AdapterEntry::ref_count|. Assumes map's |lock_| is held. |
+ AdapterRef(const scoped_refptr<WebRtcMediaStreamTrackAdapterMap>& map, |
+ Type type, |
+ const MapEntryIterator& it); |
+ |
+ AdapterEntry* entry() { return &it_->second; } |
+ |
+ scoped_refptr<WebRtcMediaStreamTrackAdapterMap> map_; |
+ Type type_; |
+ MapEntryIterator it_; |
+ // A reference to the entry's adapter, ensures that |HasOneRef| is false. |
+ scoped_refptr<WebRtcMediaStreamTrackAdapter> adapter_; |
+ }; |
+ |
+ WebRtcMediaStreamTrackAdapterMap( |
+ PeerConnectionDependencyFactory* const factory, |
+ const scoped_refptr<base::SingleThreadTaskRunner>& main_thread); |
+ |
+ // Gets the new reference to the local track adapter by ID, or null if no such |
+ // adapter was found. When all references are destroyed the adapter is |
+ // disposed and removed from the map. This method can be called from any |
+ // thread, but references must be destroyed on the main thread. |
+ std::unique_ptr<AdapterRef> GetLocalTrackAdapter(const std::string& id); |
+ // Invoke on the main thread. Gets a new reference to the local track adapter |
+ // for the web track. If no adapter exists for the track one is created and |
+ // initialized. When all references are destroyed the adapter is disposed and |
+ // removed from the map. References must be destroyed on the main thread. |
+ std::unique_ptr<AdapterRef> GetOrCreateLocalTrackAdapter( |
+ const blink::WebMediaStreamTrack& web_track); |
+ size_t GetLocalTrackCount() const; |
+ |
+ // Gets the new reference to the remote track adapter by ID, or null if no |
+ // such adapter was found. When all references are destroyed the adapter is |
+ // disposed and removed from the map. This method can be called from any |
+ // thread, but references must be destroyed on the main thread. |
+ std::unique_ptr<AdapterRef> GetRemoteTrackAdapter(const std::string& id); |
+ // Invoke on the webrtc signaling thread. Gets a new reference to the remote |
+ // track adapter for the webrtc track. If no adapter exists for the track one |
+ // is created and initialization completes on the main thread in a post. When |
+ // all references are destroyed the adapter is disposed and removed from the |
+ // map. References must be destroyed on the main thread. |
+ std::unique_ptr<AdapterRef> GetOrCreateRemoteTrackAdapter( |
+ webrtc::MediaStreamTrackInterface* webrtc_track); |
+ size_t GetRemoteTrackCount() const; |
+ |
+ protected: |
+ friend class base::RefCountedThreadSafe<WebRtcMediaStreamTrackAdapterMap>; |
+ |
+ // Invoke on the main thread. |
+ virtual ~WebRtcMediaStreamTrackAdapterMap(); |
+ |
+ private: |
+ std::unique_ptr<AdapterRef> GetTrackAdapter(AdapterRef::Type type, |
+ const std::string& id); |
+ std::unique_ptr<AdapterRef> GetOrCreateTrackAdapter( |
+ AdapterRef::Type type, |
+ base::Callback<scoped_refptr<WebRtcMediaStreamTrackAdapter>()> |
+ create_adapter_callback, |
+ const std::string& id); |
+ |
+ // Pointer to a |PeerConnectionDependencyFactory| owned by the |RenderThread|. |
+ // It's valid for the lifetime of |RenderThread|. |
+ PeerConnectionDependencyFactory* const factory_; |
+ scoped_refptr<base::SingleThreadTaskRunner> main_thread_; |
+ |
+ mutable base::Lock lock_; |
+ std::map<std::string, AdapterEntry> local_track_adapters_; |
+ std::map<std::string, AdapterEntry> remote_track_adapters_; |
+}; |
+ |
+} // namespace content |
+ |
+#endif // CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_MEDIA_STREAM_TRACK_COLLECTION_H_ |