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/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"
15
16namespace content {
17class MediaStreamDispatcher;
18
19class PepperMediaDeviceManager
20    : public MediaStreamDispatcherEventHandler,
21      public PepperDeviceEnumerationHostHelper::Delegate,
22      public RenderFrameObserver,
23      public RenderFrameObserverTracker<PepperMediaDeviceManager>,
24      public base::SupportsWeakPtr<PepperMediaDeviceManager> {
25 public:
26  static base::WeakPtr<PepperMediaDeviceManager> GetForRenderFrame(
27      RenderFrame* render_frame);
28  virtual ~PepperMediaDeviceManager();
29
30  // PepperDeviceEnumerationHostHelper::Delegate implementation:
31  virtual int EnumerateDevices(PP_DeviceType_Dev type,
32                               const GURL& document_url,
33                               const EnumerateDevicesCallback& callback)
34      OVERRIDE;
35  virtual void StopEnumerateDevices(int request_id) OVERRIDE;
36
37  typedef base::Callback<void(int /* request_id */,
38                              bool /* succeeded */,
39                              const std::string& /* label */)>
40      OpenDeviceCallback;
41
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);
57
58  // MediaStreamDispatcherEventHandler implementation.
59  virtual void OnStreamGenerated(
60      int request_id,
61      const std::string& label,
62      const StreamDeviceInfoArray& audio_device_array,
63      const StreamDeviceInfoArray& video_device_array) OVERRIDE;
64  virtual void OnStreamGenerationFailed(
65      int request_id,
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)
71      OVERRIDE;
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;
76
77  // Stream type conversion.
78  static MediaStreamType FromPepperDeviceType(PP_DeviceType_Dev type);
79  static PP_DeviceType_Dev FromMediaStreamType(MediaStreamType type);
80
81 private:
82  explicit PepperMediaDeviceManager(RenderFrame* render_frame);
83
84  // Called by StopEnumerateDevices() after returing to the event loop, to avoid
85  // a reentrancy problem.
86  void StopEnumerateDevicesDelayed(int request_id);
87
88  void NotifyDeviceOpened(int request_id,
89                          bool succeeded,
90                          const std::string& label);
91
92
93  MediaStreamDispatcher* GetMediaStreamDispatcher() const;
94
95  int next_id_;
96
97  typedef std::map<int, EnumerateDevicesCallback> EnumerateCallbackMap;
98  EnumerateCallbackMap enumerate_callbacks_;
99
100  typedef std::map<int, OpenDeviceCallback> OpenCallbackMap;
101  OpenCallbackMap open_callbacks_;
102
103  DISALLOW_COPY_AND_ASSIGN(PepperMediaDeviceManager);
104};
105
106}  // namespace content
107
108#endif  // CONTENT_RENDERER_PEPPER_PEPPER_MEDIA_DEVICE_MANAGER_H_
109