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 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_ 6 #define CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_ 7 8 #include <map> 9 10 #include "base/memory/weak_ptr.h" 11 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h" 12 #include "content/renderer/pepper/pepper_device_enumeration_host_helper.h" 13 #include "content/public/renderer/render_view_observer_tracker.h" 14 #include "content/public/renderer/render_view_observer.h" 15 16 namespace content { 17 class RenderViewImpl; 18 19 class PepperMediaDeviceManager 20 : public MediaStreamDispatcherEventHandler, 21 public PepperDeviceEnumerationHostHelper::Delegate, 22 public RenderViewObserver, 23 public RenderViewObserverTracker<PepperMediaDeviceManager>, 24 public base::SupportsWeakPtr<PepperMediaDeviceManager> { 25 public: 26 static PepperMediaDeviceManager* GetForRenderView(RenderView* render_view); 27 virtual ~PepperMediaDeviceManager(); 28 29 // PepperDeviceEnumerationHostHelper::Delegate implementation: 30 virtual int EnumerateDevices( 31 PP_DeviceType_Dev type, 32 const GURL& document_url, 33 const EnumerateDevicesCallback& callback) OVERRIDE; 34 virtual void StopEnumerateDevices(int request_id) OVERRIDE; 35 36 typedef base::Callback<void (int /* request_id */, 37 bool /* succeeded */, 38 const std::string& /* label */)> 39 OpenDeviceCallback; 40 41 // Opens the specified device. The request ID passed into the callback will be 42 // the same as the return value. If successful, the label passed into the 43 // callback identifies a audio/video steam, which can be used to call 44 // CloseDevice() and GetSesssionID(). 45 int OpenDevice(PP_DeviceType_Dev type, 46 const std::string& device_id, 47 const GURL& document_url, 48 const OpenDeviceCallback& callback); 49 // Cancels an request to open device, using the request ID returned by 50 // OpenDevice(). It is guaranteed that the callback passed into OpenDevice() 51 // won't be called afterwards. 52 void CancelOpenDevice(int request_id); 53 void CloseDevice(const std::string& label); 54 // Gets audio/video session ID given a label. 55 int GetSessionID(PP_DeviceType_Dev type, const std::string& label); 56 57 // MediaStreamDispatcherEventHandler implementation. 58 virtual void OnStreamGenerated( 59 int request_id, 60 const std::string& label, 61 const StreamDeviceInfoArray& audio_device_array, 62 const StreamDeviceInfoArray& video_device_array) OVERRIDE; 63 virtual void OnStreamGenerationFailed(int request_id) OVERRIDE; 64 virtual void OnDeviceStopped(const std::string& label, 65 const StreamDeviceInfo& device_info) OVERRIDE; 66 virtual void OnDevicesEnumerated( 67 int request_id, 68 const StreamDeviceInfoArray& device_array) OVERRIDE; 69 virtual void OnDeviceOpened( 70 int request_id, 71 const std::string& label, 72 const StreamDeviceInfo& device_info) OVERRIDE; 73 virtual void OnDeviceOpenFailed(int request_id) OVERRIDE; 74 75 // Stream type conversion. 76 static MediaStreamType FromPepperDeviceType(PP_DeviceType_Dev type); 77 static PP_DeviceType_Dev FromMediaStreamType(MediaStreamType type); 78 79 private: 80 PepperMediaDeviceManager(RenderView* render_view); 81 82 void NotifyDeviceOpened(int request_id, 83 bool succeeded, 84 const std::string& label); 85 86 RenderViewImpl* GetRenderViewImpl(); 87 88 int next_id_; 89 90 typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap; 91 EnumerateCallbackMap enumerate_callbacks_; 92 93 typedef std::map<int, OpenDeviceCallback> OpenCallbackMap; 94 OpenCallbackMap open_callbacks_; 95 96 DISALLOW_COPY_AND_ASSIGN(PepperMediaDeviceManager); 97 }; 98 99 } // namespace content 100 101 #endif // CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_ 102