Media Related changes for TabCapture API

content/browser/renderer_host/media/media_stream_manager.cc

 // Copyright (c) 2012 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 <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.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"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_observer.h"
 #include "googleurl/src/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 using content::BrowserThread;
+using content::MediaStreamRequest;
 
 namespace media_stream {
 
 // Creates a random label used to identify requests.
 static std::string RandomLabel() {
   // An earlier PeerConnection spec,
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the
   // MediaStream::label alphabet as containing 36 characters from
   // range: 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.
@@ skipping 27 matching lines @@
 void DeviceThread::Init() {
   com_initializer_.reset(new base::win::ScopedCOMInitializer(
       base::win::ScopedCOMInitializer::kMTA));
 }
 
 void DeviceThread::CleanUp() {
   com_initializer_.reset();
 }
 #endif
 
 // TODO(xians): Merge DeviceRequest with MediaStreamRequest.

[perkj_chrome, 2012/10/04 08:19:25]

Is this todo fixed by this?

[justinlin, 2012/10/08 08:59:45]

Not quite.

 struct MediaStreamManager::DeviceRequest {
-  enum RequestState {
-    STATE_NOT_REQUESTED = 0,
-    STATE_REQUESTED,
-    STATE_PENDING_APPROVAL,
-    STATE_OPENING,
-    STATE_DONE,
-    STATE_ERROR
-  };
-
   enum RequestType {
     GENERATE_STREAM = 0,
     ENUMERATE_DEVICES,
     OPEN_DEVICE
   };
 
   DeviceRequest()
       : requester(NULL),
-        state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED),
         type(GENERATE_STREAM),
         render_process_id(-1),
-        render_view_id(-1) {
+        render_view_id(-1),
+        state_(content::NUM_MEDIA_TYPES,
+              MediaStreamRequest::STATE_NOT_REQUESTED) {

[perkj_chrome, 2012/10/04 08:19:25]

indentation

[justinlin, 2012/10/08 08:59:45]

Done.

   }
 
   DeviceRequest(MediaStreamRequester* requester,
                 const StreamOptions& request_options,
                 int render_process_id,
                 int render_view_id,
                 const GURL& request_security_origin)
       : requester(requester),
         options(request_options),
-        state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED),
         type(GENERATE_STREAM),
         render_process_id(render_process_id),
         render_view_id(render_view_id),
-        security_origin(request_security_origin) {
+        security_origin(request_security_origin),
+        state_(content::NUM_MEDIA_TYPES,

[no longer working on chromium, 2012/10/04 18:41:49]

This is a struct, use state or make the struct into class.

[justinlin, 2012/10/08 08:59:45]

Done. It's kind of in an awkward state now, not sure if it's better to fully
"class"-ify this or keep it like it was before but be careful with changing the
state variable (i.e. always call notify after modifying state).

+              MediaStreamRequest::STATE_NOT_REQUESTED) {

[perkj_chrome, 2012/10/04 08:19:25]

indentation

[justinlin, 2012/10/08 08:59:45]

Done.

     DCHECK(requester);
   }
 
   ~DeviceRequest() {}
 
   MediaStreamRequester* requester;
   StreamOptions options;
-  std::vector<RequestState> state;
   RequestType type;
   int render_process_id;
   int render_view_id;
   GURL security_origin;
   std::string requested_device_id;
   StreamDeviceInfoArray devices;
+
+  void setState(int index, MediaStreamRequest::RequestState newState) {

[no longer working on chromium, 2012/10/04 18:41:49]

Oh, since you are adding functions to this struct, we should make it a class
instead. Otherwise, keep the old way.

[justinlin, 2012/10/08 08:59:45]

Done.

+    state_[index] = newState;
+  }
+
+  MediaStreamRequest::RequestState getState(int index) const {
+    return state_[index];
+  }

[perkj_chrome, 2012/10/04 08:19:25]

empty line before privat: section

[justinlin, 2012/10/08 08:59:45]

Done.

+ private:
+  std::vector<MediaStreamRequest::RequestState> state_;
 };
 
+static void NotifyObserverRequestStateChange(
+    MediaStreamManager::DeviceRequest* request,
+    MediaStreamType stream_type,
+    const MediaStreamRequest::RequestState newState,
+    const std::string& device_id) {
+  content::MediaObserver* media_observer =
+    content::GetContentClient()->browser()->GetMediaObserver();

[perkj_chrome, 2012/10/04 08:19:25]

I am not familiar with GetMediaObserver. Why is this necessary?

[justinlin, 2012/10/08 08:59:45]

Same as the other methods that notify observers.

+  if (media_observer == NULL)
+    return;
+  media_observer->OnMediaRequestStateChange(
+    request->render_process_id,
+    request->render_view_id,
+    content::MediaStreamDevice(stream_type,device_id, ""),

[no longer working on chromium, 2012/10/04 18:41:49]

one space

[justinlin, 2012/10/08 08:59:45]

Done.

+    newState);
+}
+
+// Helper to update the request state and notify observers.
+static void UpdateRequestState(
+    MediaStreamManager::DeviceRequest* request,
+    MediaStreamType stream_type,
+    const MediaStreamRequest::RequestState newState,
+    const std::string& device_id = "") {
+  request->setState(stream_type, newState);
+  NotifyObserverRequestStateChange(request, stream_type, newState, device_id);

[no longer working on chromium, 2012/10/04 18:41:49]

It does not gain anything to break it into two functions. Merge them into one
instead.

[justinlin, 2012/10/08 08:59:45]

Done.

+}
+
 MediaStreamManager::EnumerationCache::EnumerationCache()
     : valid(false) {
 }
 
 MediaStreamManager::EnumerationCache::~EnumerationCache() {
 }
 
 bool MediaStreamManager::always_use_fake_devices_ = false;
 
 // static
@@ skipping 74 matching lines @@
   device_settings_->RequestCaptureDeviceUsage(*label,
                                               render_process_id,
                                               render_view_id,
                                               options,
                                               security_origin);
   // TODO(miu): We should ask the device manager whether a device with id
   // |device_id| actually exists.  Note that no such MediaStreamProvider API for
   // this currently exists.  Also, we don't have a user-friendly device name for
   // the infobar UI.
   if (content::IsAudioMediaType(options.audio_type)) {
-    request.state[options.audio_type] = DeviceRequest::STATE_PENDING_APPROVAL;
+    UpdateRequestState(&request, options.audio_type,
+                       MediaStreamRequest::STATE_PENDING_APPROVAL,
+                       device_id);
     device_settings_->AvailableDevices(
         *label, options.audio_type, StreamDeviceInfoArray(
             1, StreamDeviceInfo(options.audio_type, device_id, device_id,
                                 false)));
   }
   if (content::IsVideoMediaType(options.video_type)) {
-    request.state[options.video_type] = DeviceRequest::STATE_PENDING_APPROVAL;
+    UpdateRequestState(&request, options.video_type,
+                       MediaStreamRequest::STATE_PENDING_APPROVAL,
+                       device_id);
     device_settings_->AvailableDevices(
         *label, options.video_type, StreamDeviceInfoArray(
             1, StreamDeviceInfo(options.video_type, device_id, device_id,
                                 false)));
   }
 }
 
 void MediaStreamManager::CancelGenerateStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     // The request isn't complete.
     if (!RequestDone(it->second)) {
       DeviceRequest& request = it->second;
       for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
            ++i) {
         const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
-        if (request.state[stream_type] != DeviceRequest::STATE_OPENING) {
+        if (request.getState(stream_type) !=
+            MediaStreamRequest::STATE_OPENING) {
           continue;
         }
         for (StreamDeviceInfoArray::const_iterator device_it =
                  request.devices.begin();
              device_it != request.devices.end(); ++device_it) {
           if (device_it->stream_type == stream_type) {
             GetDeviceManager(stream_type)->Close(device_it->session_id);
           }
         }
       }
@@ skipping 53 matching lines @@
   }
 
   DeviceRequest new_request(requester, options,
                             render_process_id,
                             render_view_id,
                             security_origin);
   new_request.type = DeviceRequest::ENUMERATE_DEVICES;
 
   if (cache->valid) {
     // Cached device list of this type exists. Just send it out.
-    new_request.state[type] = DeviceRequest::STATE_REQUESTED;
+    UpdateRequestState(&new_request, type,
+                       MediaStreamRequest::STATE_REQUESTED);
     AddRequest(new_request, label);
     // Need to post a task since the requester won't have label till
     // this function returns.
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaStreamManager::SendCachedDeviceList,
                    base::Unretained(this), cache, *label));
   } else {
     StartEnumeration(&new_request, label);
     StartMonitoring();
@@ skipping 83 matching lines @@
 
 void MediaStreamManager::StartEnumeration(
     DeviceRequest* new_request,
     std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES;
        ++i) {
     const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
     if (Requested(new_request->options, stream_type)) {
-      new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED;
+      UpdateRequestState(new_request, stream_type,
+                         MediaStreamRequest::STATE_REQUESTED);
       DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
       if (active_enumeration_ref_count_[stream_type] == 0) {
         ++active_enumeration_ref_count_[stream_type];
         GetDeviceManager(stream_type)->EnumerateDevices();
       }
     }
   }
 
   AddRequest(*new_request, label);
 }
@@ skipping 28 matching lines @@
                                         device_thread_->message_loop_proxy());
 
   video_capture_manager_ = new media_stream::VideoCaptureManager();
   video_capture_manager_->Register(this,
                                    device_thread_->message_loop_proxy());
 
   // We want to be notified of IO message loop destruction to delete the thread
   // and the device managers.
   io_loop_ = MessageLoop::current();
   io_loop_->AddDestructionObserver(this);
 }

[no longer working on chromium, 2012/10/04 18:41:49]

add back one empty line

[justinlin, 2012/10/08 08:59:45]

Done.

-
 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;
   StreamDeviceInfoArray* devices = NULL;
   std::string label;
   for (DeviceRequests::iterator request_it = requests_.begin();
        request_it != requests_.end() && request == NULL; ++request_it) {
     devices = &(request_it->second.devices);
     for (StreamDeviceInfoArray::iterator device_it = devices->begin();
          device_it != devices->end(); ++device_it) {
       if (device_it->stream_type == stream_type &&
           device_it->session_id == capture_session_id) {
         // We've found the request.
         device_it->in_use = true;
         label = request_it->first;
         request = &(request_it->second);
         break;
       }
     }
   }
   if (request == NULL) {
     // The request doesn't exist.
     return;
   }
 
-  DCHECK_NE(request->state[stream_type], DeviceRequest::STATE_REQUESTED);
+  DCHECK_NE(request->getState(stream_type),
+            MediaStreamRequest::STATE_REQUESTED);
 
   // Check if all devices for this stream type are opened. Update the state if
   // they are.
   for (StreamDeviceInfoArray::iterator device_it = devices->begin();
        device_it != devices->end(); ++device_it) {
     if (device_it->stream_type != stream_type) {
       continue;
     }
     if (device_it->in_use == false) {
       // Wait for more devices to be opened before we're done.
       return;
     }
   }
-  request->state[stream_type] = DeviceRequest::STATE_DONE;
+  UpdateRequestState(request, stream_type, MediaStreamRequest::STATE_DONE);
 
   if (!RequestDone(*request)) {
     // This stream_type is done, but not the other type.
     return;
   }
 
   switch (request->type) {
     case DeviceRequest::OPEN_DEVICE:
       request->requester->DeviceOpened(label, devices->front());
       break;
@@ skipping 46 matching lines @@
     need_update_clients = true;
   }
 
   // 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 (DeviceRequests::iterator it = requests_.begin(); it != requests_.end();
        ++it) {
-    if (it->second.state[stream_type] == DeviceRequest::STATE_REQUESTED &&
+    if (it->second.getState(stream_type) ==
+        MediaStreamRequest::STATE_REQUESTED &&
         Requested(it->second.options, stream_type)) {
       if (it->second.type != DeviceRequest::ENUMERATE_DEVICES)
-        it->second.state[stream_type] = DeviceRequest::STATE_PENDING_APPROVAL;
+        UpdateRequestState(&it->second, stream_type,

[no longer working on chromium, 2012/10/04 18:41:49]

Are you sure you want this?
The request might not from GenerateStreamForDevice

[justinlin, 2012/10/08 08:59:45]

Yes, we filter by the stream type later in the extension.

+                           MediaStreamRequest::STATE_PENDING_APPROVAL);
       label_list.push_back(it->first);
     }
   }
   for (std::list<std::string>::iterator it = label_list.begin();
        it != label_list.end(); ++it) {
     DeviceRequest& request = requests_[*it];
     switch (request.type) {
       case DeviceRequest::ENUMERATE_DEVICES:
         if (need_update_clients)
           request.requester->DevicesEnumerated(*it, devices);
         break;
       case DeviceRequest::OPEN_DEVICE:
         DCHECK(!request.requested_device_id.empty());
         for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
              device_it != devices.end(); ++device_it) {
           if (request.requested_device_id == device_it->device_id) {
             StreamDeviceInfo device = *device_it;
             device.in_use = false;
             device.session_id =
                 GetDeviceManager(device_it->stream_type)->Open(device);
-            request.state[device_it->stream_type] =
-                DeviceRequest::STATE_OPENING;
+            UpdateRequestState(&request, device_it->stream_type,
+                               MediaStreamRequest::STATE_OPENING);
             request.devices.push_back(device);
             break;
           }
         }
         break;
       default:
         device_settings_->AvailableDevices(*it, stream_type, devices);
         break;
     }
   }
@@ skipping 27 matching lines @@
         NOTREACHED();
         continue;
       }
       if (device_it->stream_type != stream_type ||
           device_it->session_id != capture_session_id) {
         continue;
       }
       // We've found the failing device. Find the error case:
       // An error should only be reported to the MediaStreamManager if
       // the request has not been fulfilled yet.
-      DCHECK(it->second.state[stream_type] != DeviceRequest::STATE_DONE);
-      if (it->second.state[stream_type] != DeviceRequest::STATE_DONE) {
+      DCHECK(it->second.getState(stream_type)
+             != MediaStreamRequest::STATE_DONE);
+      if (it->second.getState(stream_type) != MediaStreamRequest::STATE_DONE) {
         // Request is not done, devices are not opened in this case.
         if (devices.size() <= 1) {
           // 1. Device not opened and no other devices for this request ->
           //    signal stream error and remove the request.
           it->second.requester->StreamGenerationFailed(it->first);
           requests_.erase(it);
         } else {
           // 2. Not opened but other devices exists for this request -> remove
           //    device from list, but don't signal an error.
           devices.erase(device_it);  // NOTE: This invalidates device_it!
@@ skipping 23 matching lines @@
 
   // Process all newly-accepted devices for this request.
   bool found_audio = false, found_video = false;
   for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
        device_it != devices.end(); ++device_it) {
     StreamDeviceInfo device_info = *device_it;  // Make a copy.
 
     // 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.
-    DCHECK_EQ(request.state[device_it->stream_type],
-              DeviceRequest::STATE_PENDING_APPROVAL);
+    DCHECK_EQ(request.getState(device_it->stream_type),
+              MediaStreamRequest::STATE_PENDING_APPROVAL);
     device_info.in_use = false;
     device_info.session_id =
         GetDeviceManager(device_info.stream_type)->Open(device_info);
-    request.state[device_it->stream_type] = DeviceRequest::STATE_OPENING;
+    UpdateRequestState(&request, device_it->stream_type,
+                       MediaStreamRequest::STATE_OPENING,
+                       device_info.device_id);
     request.devices.push_back(device_info);
 
     if (device_info.stream_type == request.options.audio_type) {
       found_audio = true;
     } else if (device_info.stream_type == request.options.video_type) {
       found_video = true;
     }
   }
 
   // Check whether we've received all stream types requested.
   if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) {
-    request.state[request.options.audio_type] = DeviceRequest::STATE_ERROR;
+    UpdateRequestState(&request, request.options.audio_type,
+                       MediaStreamRequest::STATE_ERROR);
   }
   if (!found_video && content::IsVideoMediaType(request.options.video_type)) {
-    request.state[request.options.video_type] = DeviceRequest::STATE_ERROR;
+    UpdateRequestState(&request, request.options.video_type,
+                       MediaStreamRequest::STATE_ERROR);
   }
 }
 
 void MediaStreamManager::SettingsError(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Erase this request and report an error.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
     DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM);
     it->second.requester->StreamGenerationFailed(label);
@@ skipping 64 matching lines @@
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   const bool requested_audio =
       content::IsAudioMediaType(request.options.audio_type);
   const bool requested_video =
       content::IsVideoMediaType(request.options.video_type);
 
   const bool audio_done =
       !requested_audio ||
-      request.state[request.options.audio_type] == DeviceRequest::STATE_DONE ||
-      request.state[request.options.audio_type] == DeviceRequest::STATE_ERROR;
+      request.getState(request.options.audio_type) ==
+          MediaStreamRequest::STATE_DONE ||
+      request.getState(request.options.audio_type) ==
+          MediaStreamRequest::STATE_ERROR;
   if (!audio_done) {
     return false;
   }
 
   const bool video_done =
       !requested_video ||
-      request.state[request.options.video_type] == DeviceRequest::STATE_DONE ||
-      request.state[request.options.video_type] == DeviceRequest::STATE_ERROR;
+      request.getState(request.options.video_type) ==
+          MediaStreamRequest::STATE_DONE ||

[perkj_chrome, 2012/10/04 08:19:25]

Fits on line above, here and elsewhere?

[justinlin, 2012/10/08 08:59:45]

Done.

+      request.getState(request.options.video_type) ==
+          MediaStreamRequest::STATE_ERROR;
   if (!video_done) {
     return false;
   }
 
   for (StreamDeviceInfoArray::const_iterator it = request.devices.begin();
        it != request.devices.end(); ++it) {
     if (it->in_use == false) {
       return false;
     }
   }
@@ skipping 63 matching lines @@
        it != requests_.end(); ++it) {
     if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
         Requested(it->second.options, stream_type)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media_stream