OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // MediaStreamManager is used to open/enumerate media capture devices (video | 5 // MediaStreamManager is used to open/enumerate media capture devices (video |
6 // supported now). Call flow: | 6 // supported now). Call flow: |
7 // 1. GenerateStream is called when a render process wants to use a capture | 7 // 1. GenerateStream is called when a render process wants to use a capture |
8 // device. | 8 // device. |
9 // 2. MediaStreamManager will ask MediaStreamDeviceSettings for permission to | 9 // 2. MediaStreamManager will ask MediaStreamDeviceSettings for permission to |
10 // use devices and for which device to use. | 10 // use devices and for which device to use. |
(...skipping 11 matching lines...) Expand all Loading... |
22 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ | 22 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ |
23 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ | 23 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ |
24 | 24 |
25 #include <map> | 25 #include <map> |
26 #include <string> | 26 #include <string> |
27 #include <vector> | 27 #include <vector> |
28 | 28 |
29 #include "base/basictypes.h" | 29 #include "base/basictypes.h" |
30 #include "base/memory/scoped_ptr.h" | 30 #include "base/memory/scoped_ptr.h" |
31 #include "base/memory/ref_counted.h" | 31 #include "base/memory/ref_counted.h" |
32 #include "base/supports_user_data.h" | 32 #include "base/threading/thread.h" |
| 33 #include "base/win/scoped_com_initializer.h" |
33 #include "content/browser/renderer_host/media/media_stream_provider.h" | 34 #include "content/browser/renderer_host/media/media_stream_provider.h" |
34 #include "content/browser/renderer_host/media/media_stream_settings_requester.h" | 35 #include "content/browser/renderer_host/media/media_stream_settings_requester.h" |
35 #include "content/common/media/media_stream_options.h" | 36 #include "content/common/media/media_stream_options.h" |
36 #include "content/common/content_export.h" | 37 #include "content/common/content_export.h" |
| 38 #include "content/public/browser/browser_thread.h" |
37 | 39 |
38 namespace content { | 40 using base::win::ScopedCOMInitializer; |
39 class ResourceContext; | |
40 } | |
41 | |
42 namespace media { | |
43 class AudioManager; | |
44 } | |
45 | 41 |
46 namespace media_stream { | 42 namespace media_stream { |
47 | 43 |
48 class AudioInputDeviceManager; | 44 class AudioInputDeviceManager; |
49 class MediaStreamDeviceSettings; | 45 class MediaStreamDeviceSettings; |
50 class MediaStreamRequester; | 46 class MediaStreamRequester; |
51 class VideoCaptureManager; | 47 class VideoCaptureManager; |
52 | 48 |
| 49 // Thread that enters MTA on windows, and is base::Thread on linux and mac. |
| 50 class DeviceThread : public base::Thread { |
| 51 public: |
| 52 explicit DeviceThread(const char* name) |
| 53 : base::Thread(name), |
| 54 com_init_(ScopedCOMInitializer::kMTA) {} |
| 55 |
| 56 private: |
| 57 ScopedCOMInitializer com_init_; |
| 58 DISALLOW_COPY_AND_ASSIGN(DeviceThread); |
| 59 }; |
| 60 |
53 // MediaStreamManager is used to generate and close new media devices, not to | 61 // MediaStreamManager is used to generate and close new media devices, not to |
54 // start the media flow. | 62 // start the media flow. |
55 // The classes requesting new media streams are answered using | 63 // The classes requesting new media streams are answered using |
56 // MediaStreamManager::Listener. | 64 // MediaStreamManager::Listener. |
57 class CONTENT_EXPORT MediaStreamManager | 65 class CONTENT_EXPORT MediaStreamManager |
58 : public MediaStreamProviderListener, | 66 : public MediaStreamProviderListener, |
59 public SettingsRequester, | 67 public SettingsRequester { |
60 public base::SupportsUserData::Data { | |
61 public: | 68 public: |
62 // Returns the MediaStreamManager for the given ResourceContext. If it hasn't | 69 // This class takes the ownerships of the |audio_input_device_manager| |
63 // been created yet, it will be constructed with the given AudioManager. | 70 // and |video_capture_manager|. |
64 static MediaStreamManager* GetForResourceContext( | 71 MediaStreamManager(AudioInputDeviceManager* audio_input_device_manager, |
65 content::ResourceContext* resource_context, | 72 VideoCaptureManager* video_capture_manager); |
66 media::AudioManager* audio_manager); | |
67 | 73 |
68 explicit MediaStreamManager(media::AudioManager* audio_manager); | |
69 virtual ~MediaStreamManager(); | 74 virtual ~MediaStreamManager(); |
70 | 75 |
71 // Used to access VideoCaptureManager. | 76 // Used to access VideoCaptureManager. |
72 VideoCaptureManager* video_capture_manager(); | 77 VideoCaptureManager* video_capture_manager(); |
73 | 78 |
74 // Used to access AudioInputDeviceManager. | 79 // Used to access AudioInputDeviceManager. |
75 AudioInputDeviceManager* audio_input_device_manager(); | 80 AudioInputDeviceManager* audio_input_device_manager(); |
76 | 81 |
77 // GenerateStream opens new media devices according to |components|. The | 82 // GenerateStream opens new media devices according to |components|. The |
78 // request is identified using |label|, which is pointing to an already | 83 // request is identified using |label|, which is pointing to an already |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
123 int capture_session_id, | 128 int capture_session_id, |
124 MediaStreamProviderError error) OVERRIDE; | 129 MediaStreamProviderError error) OVERRIDE; |
125 | 130 |
126 // Implements SettingsRequester. | 131 // Implements SettingsRequester. |
127 virtual void DevicesAccepted(const std::string& label, | 132 virtual void DevicesAccepted(const std::string& label, |
128 const StreamDeviceInfoArray& devices) OVERRIDE; | 133 const StreamDeviceInfoArray& devices) OVERRIDE; |
129 virtual void SettingsError(const std::string& label) OVERRIDE; | 134 virtual void SettingsError(const std::string& label) OVERRIDE; |
130 | 135 |
131 // Used by unit test to make sure fake devices are used instead of a real | 136 // Used by unit test to make sure fake devices are used instead of a real |
132 // devices, which is needed for server based testing. | 137 // devices, which is needed for server based testing. |
| 138 // TODO(xians): Remove this hack since we can create our own |
| 139 // MediaStreamManager in our unit tests. |
133 void UseFakeDevice(); | 140 void UseFakeDevice(); |
134 | 141 |
135 private: | 142 private: |
136 // Contains all data needed to keep track of requests. | 143 // Contains all data needed to keep track of requests. |
137 struct DeviceRequest; | 144 struct DeviceRequest; |
138 | 145 |
139 // Helpers for signaling the media observer that new capture devices are | 146 // Helpers for signaling the media observer that new capture devices are |
140 // opened/closed. | 147 // opened/closed. |
141 void NotifyObserverDevicesOpened(DeviceRequest* request); | 148 void NotifyObserverDevicesOpened(DeviceRequest* request); |
142 void NotifyObserverDevicesClosed(DeviceRequest* request); | 149 void NotifyObserverDevicesClosed(DeviceRequest* request); |
143 void DevicesFromRequest(DeviceRequest* request, | 150 void DevicesFromRequest(DeviceRequest* request, |
144 content::MediaStreamDevices* devices); | 151 content::MediaStreamDevices* devices); |
145 | 152 |
146 // Helpers. | 153 // Helpers. |
147 bool RequestDone(const MediaStreamManager::DeviceRequest& request) const; | 154 bool RequestDone(const MediaStreamManager::DeviceRequest& request) const; |
148 MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type); | 155 MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type); |
149 void StartEnumeration(DeviceRequest* new_request, | 156 void StartEnumeration(DeviceRequest* new_request, |
150 std::string* label); | 157 std::string* label); |
151 | 158 |
| 159 // Helper to ensure the device thread and pass the message loop to device |
| 160 // managers, it also register itself as the listener to the device managers. |
| 161 void EnsureDeviceThreadAndListener(); |
| 162 |
| 163 // Device thread shared by VideoCaptureManager and AudioInputDeviceManager. |
| 164 scoped_ptr<base::Thread> device_thread_; |
| 165 |
152 scoped_ptr<MediaStreamDeviceSettings> device_settings_; | 166 scoped_ptr<MediaStreamDeviceSettings> device_settings_; |
| 167 scoped_refptr<AudioInputDeviceManager> audio_input_device_manager_; |
153 scoped_refptr<VideoCaptureManager> video_capture_manager_; | 168 scoped_refptr<VideoCaptureManager> video_capture_manager_; |
154 scoped_refptr<AudioInputDeviceManager> audio_input_device_manager_; | |
155 | 169 |
156 // Keeps track of device types currently being enumerated to not enumerate | 170 // Keeps track of device types currently being enumerated to not enumerate |
157 // when not necessary. | 171 // when not necessary. |
158 std::vector<bool> enumeration_in_progress_; | 172 std::vector<bool> enumeration_in_progress_; |
159 | 173 |
160 // All non-closed request. | 174 // All non-closed request. |
161 typedef std::map<std::string, DeviceRequest> DeviceRequests; | 175 typedef std::map<std::string, DeviceRequest> DeviceRequests; |
162 DeviceRequests requests_; | 176 DeviceRequests requests_; |
163 media::AudioManager* audio_manager_; | |
164 | 177 |
165 DISALLOW_COPY_AND_ASSIGN(MediaStreamManager); | 178 DISALLOW_COPY_AND_ASSIGN(MediaStreamManager); |
166 }; | 179 }; |
167 | 180 |
168 } // namespace media_stream | 181 } // namespace media_stream |
169 | 182 |
170 #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ | 183 #endif // CONTENT_BROWSER_RENDERER_HOST_MEDIA_MEDIA_STREAM_MANAGER_H_ |
OLD | NEW |