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.
5 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_
6 #define CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_
10 #include "base/memory/weak_ptr.h"
11 #include "content/public/renderer/render_frame_observer.h"
12 #include "content/public/renderer/render_frame_observer_tracker.h"
13 #include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
14 #include "content/renderer/pepper/pepper_device_enumeration_host_helper.h"
17 class MediaStreamDispatcher;
19 class PepperMediaDeviceManager
20 : public MediaStreamDispatcherEventHandler,
21 public PepperDeviceEnumerationHostHelper::Delegate,
22 public RenderFrameObserver,
23 public RenderFrameObserverTracker<PepperMediaDeviceManager>,
24 public base::SupportsWeakPtr<PepperMediaDeviceManager> {
26 static base::WeakPtr<PepperMediaDeviceManager> GetForRenderFrame(
27 RenderFrame* render_frame);
28 virtual ~PepperMediaDeviceManager();
30 // PepperDeviceEnumerationHostHelper::Delegate implementation:
31 virtual int EnumerateDevices(PP_DeviceType_Dev type,
32 const GURL& document_url,
33 const EnumerateDevicesCallback& callback)
35 virtual void StopEnumerateDevices(int request_id) OVERRIDE;
37 typedef base::Callback<void(int /* request_id */,
39 const std::string& /* label */)>
42 // Opens the specified device. The request ID passed into the callback will be
43 // the same as the return value. If successful, the label passed into the
44 // callback identifies a audio/video steam, which can be used to call
45 // CloseDevice() and GetSesssionID().
46 int OpenDevice(PP_DeviceType_Dev type,
47 const std::string& device_id,
48 const GURL& document_url,
49 const OpenDeviceCallback& callback);
50 // Cancels an request to open device, using the request ID returned by
51 // OpenDevice(). It is guaranteed that the callback passed into OpenDevice()
52 // won't be called afterwards.
53 void CancelOpenDevice(int request_id);
54 void CloseDevice(const std::string& label);
55 // Gets audio/video session ID given a label.
56 int GetSessionID(PP_DeviceType_Dev type, const std::string& label);
58 // MediaStreamDispatcherEventHandler implementation.
59 virtual void OnStreamGenerated(
61 const std::string& label,
62 const StreamDeviceInfoArray& audio_device_array,
63 const StreamDeviceInfoArray& video_device_array) OVERRIDE;
64 virtual void OnStreamGenerationFailed(
66 content::MediaStreamRequestResult result) OVERRIDE;
67 virtual void OnDeviceStopped(const std::string& label,
68 const StreamDeviceInfo& device_info) OVERRIDE;
69 virtual void OnDevicesEnumerated(int request_id,
70 const StreamDeviceInfoArray& device_array)
72 virtual void OnDeviceOpened(int request_id,
73 const std::string& label,
74 const StreamDeviceInfo& device_info) OVERRIDE;
75 virtual void OnDeviceOpenFailed(int request_id) OVERRIDE;
77 // Stream type conversion.
78 static MediaStreamType FromPepperDeviceType(PP_DeviceType_Dev type);
79 static PP_DeviceType_Dev FromMediaStreamType(MediaStreamType type);
82 explicit PepperMediaDeviceManager(RenderFrame* render_frame);
84 // Called by StopEnumerateDevices() after returing to the event loop, to avoid
85 // a reentrancy problem.
86 void StopEnumerateDevicesDelayed(int request_id);
88 void NotifyDeviceOpened(int request_id,
90 const std::string& label);
93 MediaStreamDispatcher* GetMediaStreamDispatcher() const;
97 typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap;
98 EnumerateCallbackMap enumerate_callbacks_;
100 typedef std::map<int, OpenDeviceCallback> OpenCallbackMap;
101 OpenCallbackMap open_callbacks_;
103 DISALLOW_COPY_AND_ASSIGN(PepperMediaDeviceManager);
106 } // namespace content
108 #endif // CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_