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(PP_DeviceType_Dev type, 31 const GURL& document_url, 32 const EnumerateDevicesCallback& callback) 33 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( 64 int request_id, 65 content::MediaStreamRequestResult result) OVERRIDE; 66 virtual void OnDeviceStopped(const std::string& label, 67 const StreamDeviceInfo& device_info) OVERRIDE; 68 virtual void OnDevicesEnumerated(int request_id, 69 const StreamDeviceInfoArray& device_array) 70 OVERRIDE; 71 virtual void OnDeviceOpened(int request_id, 72 const std::string& label, 73 const StreamDeviceInfo& device_info) OVERRIDE; 74 virtual void OnDeviceOpenFailed(int request_id) OVERRIDE; 75 76 // Stream type conversion. 77 static MediaStreamType FromPepperDeviceType(PP_DeviceType_Dev type); 78 static PP_DeviceType_Dev FromMediaStreamType(MediaStreamType type); 79 80 private: 81 PepperMediaDeviceManager(RenderView* render_view); 82 83 void NotifyDeviceOpened(int request_id, 84 bool succeeded, 85 const std::string& label); 86 87 RenderViewImpl* GetRenderViewImpl(); 88 89 int next_id_; 90 91 typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap; 92 EnumerateCallbackMap enumerate_callbacks_; 93 94 typedef std::map<int, OpenDeviceCallback> OpenCallbackMap; 95 OpenCallbackMap open_callbacks_; 96 97 DISALLOW_COPY_AND_ASSIGN(PepperMediaDeviceManager); 98 }; 99 100 } // namespace content 101 102 #endif // CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_ 103