Adding MediaStreamManager.

content/browser/renderer_host/media/media_stream_manager.cc

+// 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.
+
+#include "content/browser/renderer_host/media/media_stream_manager.h"
+
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/rand_util.h"
+#include "content/browser/browser_thread.h"
+#include "content/browser/renderer_host/media/media_stream_device_settings.h"
+#include "content/browser/renderer_host/media/media_stream_requester.h"
+#include "content/browser/renderer_host/media/video_capture_manager.h"
+#include "content/common/media/media_stream_options.h"
+
+namespace media_stream {
+
+// TODO(mflodman) Find out who should own MediaStreamManager.
+base::LazyInstance<MediaStreamManager> g_media_stream_manager(
+    base::LINKER_INITIALIZED);
+
+// Creates a random label used to identify requests.
+static std::string RandomLabel() {
+  static const char alphabet[] = "0123456789"

[Leandro Graciá Gil, 2011/07/01 11:31:35]

I think this comes from the old demo code (and hence my error with the sizeof).
This should probably work, but I think we never checked that this alphabet was
exactly the one covered by the spec about the labels. Also, the length seems to
be outdated too. Could you please check it?

Copy/paste from today's version of the spec:
When a LocalMediaStream object is created, the user agent must generate a
globally unique identifier string, and must initialize the object's label
attribute to that string. Such strings must only use characters in the ranges
U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E, U+0030 to U+0039,
U+0041 to U+005A, U+005E to U+007E, and must be 36 characters long.

[mflodman1, 2011/07/01 14:07:23]

Length updated. The label is used in Chrome internally and is modified in some
way before it's delivered to the java script. I'll check with grunell about this
before changing the alphabet, putting a TODO for now.

[mflodman1, 2011/07/04 21:43:14]

Updated according to WhatWG spec.

+      "abcdefghijklmnopqrstuvwxyz"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  std::string label(63, ' ');
+  for (size_t i = 0; i < label.size(); ++i) {
+    int random_char = base::RandGenerator(sizeof(alphabet) - 1);
+    label[i] = alphabet[random_char];
+  }
+  return label;
+}
+
+// Helper to verify if a media stream type is part of options or not.
+static bool Requested(const StreamOptions& options,
+                      MediaStreamType stream_type) {
+  if (stream_type == kVideoCapture
+      && (options.video_option != StreamOptions::kNoCamera)) {

[Leandro Graciá Gil, 2011/07/01 11:31:35]

What if stream_type asks for video but options don't (or the other way around)?
This is being checked but it's probably something that shouldn't happen. Maybe
we should DCHECK it?

[mflodman1, 2011/07/01 14:07:23]

This is just a helper to see if the stream type is part of options or not.
(stream_type set by MediaStreamManager and options comes from WebKit). If it is
-> return true, else false. E.g. we want to return false if stream_type is
kVideoCapture and options.video_option == kNoCamera, i.e. we want to know if
video was requested but it wasn't.

Or did I misunderstand your question?

+    return true;
+  } else if (stream_type == kAudioCapture && options.audio == true) {
+    return true;
+  }
+  return false;
+}
+
+MediaStreamManager* MediaStreamManager::Get() {
+  return g_media_stream_manager.Pointer();
+}
+
+MediaStreamManager::~MediaStreamManager() {
+  delete device_settings_;
+  delete video_capture_manager_;
+}
+
+VideoCaptureManager* MediaStreamManager::GetVideoCaptureManager() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return video_capture_manager_;
+}
+
+void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
+                                        int render_process_id,
+                                        int render_view_id,
+                                        const StreamOptions& options,
+                                        const std::string& security_origin,
+                                        std::string* label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // TODO(mflodman) Remove next line when audio is supported.
+  (const_cast<StreamOptions&>(options)).audio = false;
+
+  // Create a new request based on options.
+  DeviceRequest new_request = DeviceRequest(requester, options);
+  if (Requested(new_request.options, kAudioCapture)) {
+    new_request.state[kAudioCapture] = DeviceRequest::kRequested;
+  }
+  if (Requested(new_request.options, kVideoCapture)) {
+    new_request.state[kVideoCapture] = DeviceRequest::kRequested;
+  }
+
+  // Create a label for this request and verify it is unique.
+  new_request.label = RandomLabel();
+  for (DeviceRequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    if (new_request.label == it->label) {

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Does the request list contain the labels of existing streams which requests have
been solved? I want to make sure that the random label doesn't collide with an
existing stream label (maybe even in the ended state, that's probably something
to discuss) and not only with ongoing requests.

In any case, have you considered using a separate set/hash_set for the labels in
use or even make the request list a map/hash_map indexed by its label? Probably
it's worth it to simplify the code, save some iterator loops and enhance the
asymptotic costs, but it's up to you. If you do, make sure no ordering issues
may arise when selecting the container.

[mflodman1, 2011/07/01 14:07:23]

A request is stored until the stream is either closed by a call to
StopGeneratedStream or until the entire stream gets an error and
StreamGenerationFailed is signalled. So there should never be two streams using
the same label at any time.
I'll look at this, but I'll upload a new patch with the other changes as a
start.

[mflodman1, 2011/07/04 21:43:14]

Done.

+      new_request.label = RandomLabel();
+      it = requests_.begin();
+    }
+  }
+  requests_.push_back(new_request);
+
+  // Get user confirmation to use capture devices.
+  device_settings_->RequestCaptureDeviceUsage(new_request.label,
+                                              render_process_id, render_view_id,
+                                              options, security_origin);
+  (*label) = new_request.label;
+}
+
+void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  DeviceRequestList::iterator it = requests_.begin();
+  while (it != requests_.end()) {
+    if (it->requester == requester && !RequestDone(*it)) {
+      it = requests_.erase(it);
+      it = requests_.begin();
+    } else {
+      ++it;
+    }
+  }
+}
+
+void MediaStreamManager::StopGeneratedStream(const std::string& label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Find the request and close all open devices for the request.
+  for (DeviceRequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    if (it->label == label) {
+      for (StreamDeviceInfoArray::iterator audio_it = it->audio_devices.begin();
+           audio_it != it->audio_devices.end(); ++audio_it) {
+        // TODO(mflodman) Add code when audio input manager exists.
+        DCHECK(false);
+      }
+      for (StreamDeviceInfoArray::iterator video_it = it->video_devices.begin();
+           video_it != it->video_devices.end(); ++video_it) {
+        video_capture_manager_->Close(video_it->session_id);
+      }
+      requests_.erase(it);
+      return;
+    }
+  }
+}
+
+void MediaStreamManager::Opened(MediaStreamType stream_type,
+                                int capture_session_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Find the request containing this device and mark it as used.
+  DeviceRequest* request = NULL;
+  StreamDeviceInfo* device = NULL;
+  for (DeviceRequestList::iterator request_it = requests_.begin();
+       request_it != requests_.end() && request == NULL; ++request_it) {
+    StreamDeviceInfoArray* devices = NULL;
+    if (stream_type == kAudioCapture) {
+      devices = &(request_it->audio_devices);
+    } else if (stream_type == kVideoCapture) {
+      devices = &(request_it->video_devices);
+    } else {
+      DCHECK(false);
+    }
+
+    for (StreamDeviceInfoArray::iterator device_it = devices->begin();
+         device_it != devices->end(); ++device_it) {
+      if (device_it->session_id == capture_session_id) {
+        // We've found the request.
+
+        request = &(*request_it);
+        device = &(*device_it);
+        break;
+      }
+    }
+  }
+  if (request == NULL) {
+    // The request doesn't exist.

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Can this happen in legitimate situations without being a failure? If not we
should DCHECK.

[mflodman1, 2011/07/01 14:07:23]

Yes, the request can be canceled during the time the device is opened by
VideocaptureManager, which happens on another thread.

+    return;
+  }
+
+  device->in_use = true;

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Is there a possibility that the device is already in use? (I guess not, but I
see no reason not to ask.)

[mflodman1, 2011/07/01 14:07:23]

A device is marked as in_use by the VideoCaptureManager/AudioInputDeviceManager
if it has been opened in a stream already. For audio we allow the same device to
be opened several times, and might allow for video as well later, so for this
request we set in_use to false in DevicesAccepted before asking the
corresponding manager to open it. This is to be able to track when this request
is done.

+  if (!RequestDone(*request)) {
+    // Wait for more devices to be opened before we're done.
+    return;
+  }
+
+  if (request->state[kAudioCapture] == DeviceRequest::kOpening) {

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Which other states are valid here? Maybe it's worth to DCHECK.

[mflodman1, 2011/07/01 14:07:23]

It should only be kRequested that is invalid, meaning we have requested it from
the UI but never received user acceptance to use it. I'll add a DCHECK for that.

+    request->state[kAudioCapture] = DeviceRequest::kDone;
+  }
+  if (request->state[kVideoCapture] == DeviceRequest::kOpening) {
+    request->state[kVideoCapture] = DeviceRequest::kDone;
+  }
+
+  request->requester->StreamGenerated(request->label, request->audio_devices,
+                                      request->video_devices);
+}
+
+void MediaStreamManager::Closed(MediaStreamType stream_type,
+                                int capture_session_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+}
+
+void MediaStreamManager::DevicesEnumerated(
+    MediaStreamType stream_type, const StreamDeviceInfoArray& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Publish the result for all requests waiting for device list(s).
+  // Find the requests waiting for this device list, store their labels and
+  // release the iterator before calling device settings. We might get a call
+  // back from device_settings that will need to iterate through devices.
+  std::list<std::string> label_list;
+  for (DeviceRequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    if (it->state[stream_type] == DeviceRequest::kRequested
+        && Requested(it->options, stream_type)) {
+      label_list.push_back(it->label);
+    }
+  }
+  while (label_list.size()) {
+    device_settings_->AvailableDevices(label_list.front(), stream_type,
+                                       devices);
+    label_list.pop_front();

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Since label_list is local and you always pop the first element in each
iteration, shouldn't it be easier and more efficient just to use a std::vector
for label_list and then iterate it?

[mflodman1, 2011/07/01 14:07:23]

I changed to iterate the list and then do clear when everything is done instead
of the way it was. The drawback of using a vector is I don't know the size it
should be. I know how many requests there are in total and can allocate that
size of the vector, but there is a risk of over-allocating each time this is
done. Do you still think it's better using vector instead of list?

+  }
+  enumeration_in_progress_[stream_type] = false;
+}
+
+void MediaStreamManager::Error(MediaStreamType stream_type,
+                               int capture_session_id,
+                               MediaStreamProviderError error) {
+  // Find the device for the error call.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  for (DeviceRequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    StreamDeviceInfoArray* devices = NULL;
+    if (stream_type == kAudioCapture) {
+      devices = &(it->audio_devices);
+    } else if (stream_type == kVideoCapture) {
+      devices = &(it->video_devices);
+    } else {
+      DCHECK(false);

[Leandro Graciá Gil, 2011/07/01 11:31:35]

Use NOTREACHED().

[mflodman1, 2011/07/01 14:07:23]

Done.

+    }
+
+    int device_idx = 0;
+    for (StreamDeviceInfoArray::iterator device_it = devices->begin();
+         device_it != devices->end(); ++device_it, ++device_idx) {
+      if (device_it->session_id == capture_session_id) {
+        // We've found the failing device. Find the error case:
+        if (it->state[stream_type] == DeviceRequest::kDone) {
+          // 1. Already opened -> signal device failure and close device.
+          //    Use device_idx to signal which of the devices encountered an
+          //    error.
+          if (stream_type == kAudioCapture) {
+            it->requester->AudioDeviceFailed(it->label, device_idx);
+          } else if (stream_type == kVideoCapture) {
+            it->requester->VideoDeviceFailed(it->label, device_idx);
+          }
+          GetDeviceManager(stream_type)->Close(capture_session_id);
+          devices->erase(device_it);

[Leandro Graciá Gil, 2011/07/01 11:31:35]

This will move all the elements after it in the devices vector. If these erases
are going to be frequent maybe we should change the container type to something
else.

[mflodman1, 2011/07/01 14:07:23]

It won't happen often and it's likely the vector contains only one element, so
I'll keep as is for now.

+        } else if (it->audio_devices.size() + it->video_devices.size() <= 1) {
+          // 2. Device not opened and no other devices for this request ->
+          //    signal stream error and remove the request.
+          it->requester->StreamGenerationFailed(it->label);
+          requests_.erase(it);
+        } else {
+          // 3. Not opened but other devices exists for this request -> remove
+          //    device from list, but don't signal an error.
+          devices->erase(device_it);
+        }
+        return;
+      }
+    }
+  }
+}
+
+void MediaStreamManager::GetDevices(const std::string& label,
+                                    MediaStreamType stream_type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!enumeration_in_progress_[stream_type]) {
+    enumeration_in_progress_[stream_type] = true;
+    GetDeviceManager(stream_type)->EnumerateDevices();
+  }
+}
+
+void MediaStreamManager::DevicesAccepted(const std::string& label,
+                                         const StreamDeviceInfoArray& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  for (DeviceRequestList::iterator request_it = requests_.begin();
+       request_it != requests_.end(); ++request_it) {
+    if (request_it->label == label) {
+      // We've found our request.
+      if (devices.empty()) {
+        // No available devices or user didn't accept device usage.
+        request_it->requester->StreamGenerationFailed(request_it->label);
+        requests_.erase(request_it);
+        return;
+      }
+
+      // Loop through all device types for this request.
+      for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
+           device_it != devices.end(); ++device_it) {
+        StreamDeviceInfo device_info = *device_it;
+
+        // Set in_use to false to be able to track if this device has been
+        // opened. in_use might be true if the device type can be used in more
+        // than one session.
+        device_info.in_use = false;
+        device_info.session_id =
+            GetDeviceManager(device_info.stream_type)->Open(device_info);
+        request_it->state[device_it->stream_type] = DeviceRequest::kOpening;
+        if (device_info.stream_type == kAudioCapture) {
+          request_it->audio_devices.push_back(device_info);
+        } else if (device_info.stream_type == kVideoCapture) {
+          request_it->video_devices.push_back(device_info);
+        } else {
+          DCHECK(false);

[Leandro Graciá Gil, 2011/07/01 11:31:35]

NOTREACHED()

[mflodman1, 2011/07/01 14:07:23]

Done.

+        }
+      }
+      return;
+    }
+  }
+}
+
+void MediaStreamManager::SettingsError(const std::string& label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Erase this request and report an error.
+  for (DeviceRequestList::iterator it = requests_.begin();
+       it != requests_.end(); ++it) {
+    if (it->label == label) {
+      // We've found our request. erase it and report error.
+      it->requester->StreamGenerationFailed(label);
+      requests_.erase(it);
+      return;
+    }
+  }
+}
+
+void MediaStreamManager::UseFakeDevice() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  video_capture_manager_->UseFakeDevice();
+  // TODO(mflodman) Add audio manager when available.
+}
+
+bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Check if all devices are opened.
+  if (Requested(request.options, kAudioCapture)) {
+    for (StreamDeviceInfoArray::const_iterator it =
+         request.audio_devices.begin(); it != request.audio_devices.end();
+         ++it) {
+      if (it->in_use == false) {
+        return false;
+      }
+    }
+  }
+  if (Requested(request.options, kVideoCapture)) {
+      for (StreamDeviceInfoArray::const_iterator it =
+           request.video_devices.begin(); it != request.video_devices.end();
+           ++it) {
+        if (it->in_use == false) {
+          return false;
+        }
+      }
+    }
+  return true;
+}
+
+// Called to get media capture device manager of specified type.
+MediaStreamProvider* MediaStreamManager::GetDeviceManager(
+    MediaStreamType stream_type) const {
+  if (stream_type == kVideoCapture) {
+    return video_capture_manager_;
+  } else if (stream_type == kAudioCapture) {
+    // TODO(mflodman) Add support when audio input manager is available.
+    DCHECK(false);
+    return NULL;
+  }
+  DCHECK(false);
+  return NULL;
+}
+
+MediaStreamManager::MediaStreamManager()
+    : video_capture_manager_(new VideoCaptureManager()),
+      enumeration_in_progress_(kNumMediaStreamTypes, false),
+      requests_(),
+      device_settings_(NULL) {
+  device_settings_ = new MediaStreamDeviceSettings(this);
+  video_capture_manager_->Register(this);
+  // TODO(mflodman) Add when audio input manager is available.
+}
+
+}  // namespace media_stream