VideoCaptureManager opens/closes, starts/stops and enumerates video capture devices. VideoCapture...

content/browser/media_stream/media_stream_provider.h

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_MEDIA_STREAM_MEDIA_STREAM_PROVIDER_H_
+#define CONTENT_BROWSER_MEDIA_STREAM_MEDIA_STREAM_PROVIDER_H_
+
+#include <list>
+#include <string>
+
+namespace media_stream {
+
+// TODO(mflodman) Create a common type to use for all video capture and media
+// stream classes.
+typedef int MediaCaptureSessionId;
+
+enum MediaStreamType {
+  kNoService = 0,
+  kAudioCapture,
+  kVideoCapture
+};
+
+enum MediaStreamProviderError {
+  kMediaStreamOk = 0,
+  kInvalidMediaStreamType,
+  kInvalidSession,
+  kUnknownSession,
+  kDeviceNotAvailable,
+  kDeviceAlreadyInUse,
+  kUnknownError
+};
+
+struct MediaCaptureDeviceInfo {
+  MediaStreamType stream_type;
+  std::string name;
+  std::string device_id;
+  bool in_use;
+
+  MediaCaptureDeviceInfo() : stream_type(kNoService), name(), device_id(),
+      in_use(false) {}
+  MediaCaptureDeviceInfo(MediaStreamType service_param,
+                         const std::string name_param,
+                         const std::string device_param,
+                         bool opened)
+      : stream_type(service_param),
+        name(name_param),
+        device_id(device_param),
+        in_use(opened) {}
+};
+
+typedef std::list<MediaCaptureDeviceInfo> MediaCaptureDevices;
+
+// Feedback class used by MediaStreamProvider.

[John Knottenbelt, 2011/05/11 11:36:35]

Optional: perhaps "Callback class" might better indicate the purpose than
"Feedback class"

[mflodman1, 2011/05/15 20:24:00]

Done.

+class MediaStreamProviderListener {
+ public:
+  // Called by a MediaStreamProvider when a stream has been opened.
+  virtual void Opened(MediaStreamType stream_type,

[John Knottenbelt, 2011/05/11 11:36:35]

Question: Since the MediaCaptureSessionId is being passed in, is it necessary to
also pass in the stream type?

Question: Also, I get the feeling that these interfaces are intended to only
ever deal with one stream type. Does it complicate things if you drop it as an
argument from all the methods in this class and also MediaStreamProvider?

[mflodman1, 2011/05/15 20:24:00]

The plan is to have the MediaStreamManager instance registered as listener for
both VideoCaptureManager and the audio manager. That's why the stream_type is an
argument for the callbacks, to know which MediaStreamProvider is calling that
callback.

I think the stream type can be removed in MediaStreamProvider though, since
there will be one MediaStreamProvider per media type.

+                      MediaCaptureSessionId capture_session_id) = 0;
+
+  // Called by a MediaStreamProvider when a stream has been closed.
+  virtual void Closed(MediaStreamType stream_type,
+                      MediaCaptureSessionId capture_session_id) = 0;
+
+  // Called by a MediaStreamProvider when available devices has been enumerated.
+  virtual void DevicesEnumerated(MediaStreamType stream_type,
+                                 const MediaCaptureDevices& devices) = 0;
+
+  // Called by a MediaStreamProvider when an error has occured.
+  virtual void Error(MediaStreamType stream_type,
+                     MediaCaptureSessionId capture_session_id,
+                     MediaStreamProviderError error) = 0;
+
+ protected:
+  virtual ~MediaStreamProviderListener() {}
+};
+
+// Implemented by a manager class providing captured media.
+class MediaStreamProvider {
+ public:
+  // Registers a listener, only one listener is allowed.

[John Knottenbelt, 2011/05/11 11:36:35]

Please clarify: is this one listener per service type, or one listener in total?

[mflodman1, 2011/05/15 20:24:00]

There can be only one listener registered per MediaSteamProvider instance, but
the plan is to use the single MediaStreamManager instance as listener for all
MediaStreamProviders.
I added a comment at the top of this file that hopefully explains this.

+  virtual bool Register(MediaStreamType service_type,
+                       MediaStreamProviderListener* listener) = 0;
+
+  // Unregisters the previously registered listener.
+  virtual void Unregister(MediaStreamType stream_type,
+                          MediaStreamProviderListener* listener) = 0;
+
+  // Enumerates existing capture devices and calls |DevicesEnumerated|.
+  virtual void EnumerateDevices(MediaStreamType stream_type) = 0;
+
+  // Opens the specified device. The device is not started and it is still
+  // possible for other applications to open the device before the device is
+  // started. |Opened| is called when the device is opened.
+  virtual MediaCaptureSessionId Open(MediaStreamType stream_type,
+                                     const MediaCaptureDeviceInfo& device) = 0;
+
+  // Closes the specified device and calls |Closed| when done.
+  virtual void Close(MediaStreamType stream_type,
+                     MediaCaptureSessionId capture_session_id) = 0;
+
+ protected:
+  virtual ~MediaStreamProvider() {}
+};
+
+}  // namespace media_stream
+
+#endif  // CONTENT_BROWSER_MEDIA_STREAM_MEDIA_STREAM_PROVIDER_H_