Replace MediaStreamUIController with MediaStreamUIProxy.

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/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/threading/thread.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_requester.h"
-#include "content/browser/renderer_host/media/media_stream_ui_controller.h"
+#include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/browser/renderer_host/media/web_contents_capture_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
 #include "googleurl/src/gurl.h"
 #include "media/audio/audio_manager_base.h"
@@ skipping 19 matching lines @@
 
   std::string label(36, ' ');
   for (size_t i = 0; i < label.size(); ++i) {
     int random_char = base::RandGenerator(sizeof(kAlphabet) - 1);
     label[i] = kAlphabet[random_char];
   }
   return label;
 }
 
 // Helper to verify if a media stream type is part of options or not.
-static bool Requested(const StreamOptions& options,
+static bool Requested(const MediaStreamRequest& request,
                       MediaStreamType stream_type) {
-  return (options.audio_type == stream_type ||
-          options.video_type == stream_type);
+  return (request.audio_type == stream_type ||
+          request.video_type == stream_type);
 }
 
 // TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 class MediaStreamManager::DeviceRequest {
  public:
-  DeviceRequest()
-      : requester(NULL),
-        type(MEDIA_GENERATE_STREAM),
-        render_process_id(-1),
-        render_view_id(-1),
+  DeviceRequest(MediaStreamRequester* requester,
+                const MediaStreamRequest& request)
+      : requester(requester),
+        request(request),
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED) {
   }
 
-  DeviceRequest(MediaStreamRequester* requester,
-                const StreamOptions& request_options,
-                MediaStreamRequestType request_type,
-                int render_process_id,
-                int render_view_id,
-                const GURL& request_security_origin,
-                const std::string& requested_device_id)
-      : requester(requester),
-        options(request_options),
-        type(request_type),
-        render_process_id(render_process_id),
-        render_view_id(render_view_id),
-        security_origin(request_security_origin),
-        requested_device_id(requested_device_id),
-        state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED) {
-  }
-
   ~DeviceRequest() {}
 
   // Update the request state and notify observers.
   void SetState(MediaStreamType stream_type, MediaRequestState new_state) {
     state_[stream_type] = new_state;
 
-    if (options.video_type != MEDIA_TAB_VIDEO_CAPTURE &&
-        options.audio_type != MEDIA_TAB_AUDIO_CAPTURE) {
+    if (request.video_type != MEDIA_TAB_VIDEO_CAPTURE &&
+        request.audio_type != MEDIA_TAB_AUDIO_CAPTURE) {
       return;
     }
 
     MediaObserver* media_observer =
         GetContentClient()->browser()->GetMediaObserver();
     if (media_observer == NULL)
       return;
 
     // If we appended a device_id scheme, we want to remove it when notifying
     // observers which may be in different modules since this scheme is only
     // used internally within the content module.
     std::string device_id =
         WebContentsCaptureUtil::StripWebContentsDeviceScheme(
-            requested_device_id);
+            request.requested_device_id);
 
     media_observer->OnMediaRequestStateChanged(
-        render_process_id, render_view_id,
-        MediaStreamDevice(
-            stream_type, device_id, device_id), new_state);
+        request.render_process_id, request.render_view_id,
+        MediaStreamDevice(stream_type, device_id, device_id), new_state);
   }
 
   MediaRequestState state(MediaStreamType stream_type) const {
     return state_[stream_type];
   }
 
   MediaStreamRequester* const requester;  // Can be NULL.
-  const StreamOptions options;
-  const MediaStreamRequestType type;
-  const int render_process_id;
-  const int render_view_id;
-  const GURL security_origin;
-  const std::string requested_device_id;
+  MediaStreamRequest request;
+
   StreamDeviceInfoArray devices;
 
   // Callback to the requester which audio/video devices have been selected.
   // It can be null if the requester has no interest to know the result.
   // Currently it is only used by |DEVICE_ACCESS| type.
-  MediaRequestResponseCallback callback;
+  MediaStreamManager::MediaRequestResponseCallback callback;
+
+  scoped_ptr<MediaStreamUIProxy> ui_proxy;
 
  private:
   std::vector<MediaRequestState> state_;
 };
 
 MediaStreamManager::EnumerationCache::EnumerationCache()
     : valid(false) {
 }
 
 MediaStreamManager::EnumerationCache::~EnumerationCache() {
 }
 
 MediaStreamManager::MediaStreamManager(media::AudioManager* audio_manager)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(
-          ui_controller_(new MediaStreamUIController(this))),
-      audio_manager_(audio_manager),
+    : audio_manager_(audio_manager),
       monitoring_started_(false),
       io_loop_(NULL),
-      screen_capture_active_(false) {
+      screen_capture_active_(false),
+      use_fake_ui_(false) {
   DCHECK(audio_manager_);
   memset(active_enumeration_ref_count_, 0,
          sizeof(active_enumeration_ref_count_));
 
   // Some unit tests create the MSM in the IO thread and assumes the
   // initialization is done synchronously.
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     InitializeDeviceManagersOnIOThread();
   } else {
     BrowserThread::PostTask(
@@ skipping 22 matching lines @@
 }
 
 std::string MediaStreamManager::MakeMediaAccessRequest(
     int render_process_id,
     int render_view_id,
     const StreamOptions& options,
     const GURL& security_origin,
     const MediaRequestResponseCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Create a new request based on options.
-  DeviceRequest* request = new DeviceRequest(NULL,
-                                             options,
-                                             MEDIA_DEVICE_ACCESS,
-                                             render_process_id,
-                                             render_view_id,
-                                             security_origin,
-                                             std::string());
+  MediaStreamRequest stream_request(
+      render_process_id, render_view_id, security_origin,
+      MEDIA_DEVICE_ACCESS, std::string(),
+      options.audio_type, options.video_type);
+  DeviceRequest* request = new DeviceRequest(NULL, stream_request);
   const std::string& label = AddRequest(request);
 
   request->callback = callback;
 
   HandleRequest(label);
 
   return label;
 }
 
 std::string MediaStreamManager::GenerateStream(
@@ skipping 46 matching lines @@
       // TODO(sergeyu): Implement support for more than one concurrent screen
       // capture streams.
       LOG(ERROR) << "Another screen capture stream is active.";
       return std::string();
     }
 
     screen_capture_active_ = true;
   }
 
   // Create a new request based on options.
-  DeviceRequest* request = new DeviceRequest(requester,
-                                             options,
-                                             MEDIA_GENERATE_STREAM,
-                                             target_render_process_id,
-                                             target_render_view_id,
-                                             security_origin,
-                                             requested_device_id);
+  MediaStreamRequest stream_request(
+      target_render_process_id, target_render_view_id, security_origin,
+      MEDIA_GENERATE_STREAM, requested_device_id,
+      options.audio_type, options.video_type);
+  DeviceRequest* request = new DeviceRequest(requester, stream_request);
   const std::string& label = AddRequest(request);
   HandleRequest(label);
   return label;
 }
 
 void MediaStreamManager::CancelRequest(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
-    // The request isn't complete, notify the UI immediately.
-    ui_controller_->CancelUIRequest(label);
-
     if (!RequestDone(*it->second)) {
       // TODO(xians): update the |state| to STATE_DONE to trigger a state
       // changed notification to UI before deleting the request?
       scoped_ptr<DeviceRequest> request(it->second);
       RemoveRequest(it);
       for (int i = MEDIA_NO_SERVICE + 1; i < NUM_MEDIA_TYPES; ++i) {
         const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
         MediaStreamProvider* device_manager = GetDeviceManager(stream_type);
         if (!device_manager)
           continue;
@@ skipping 13 matching lines @@
     }
   }
 }
 
 void MediaStreamManager::StopGeneratedStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Find the request and close all open devices for the request.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
-    if (it->second->type == MEDIA_ENUMERATE_DEVICES) {
+    if (it->second->request.request_type == MEDIA_ENUMERATE_DEVICES) {
       StopEnumerateDevices(label);
       return;
     }
 
     scoped_ptr<DeviceRequest> request(it->second);
     RemoveRequest(it);
     for (StreamDeviceInfoArray::const_iterator device_it =
              request->devices.begin();
          device_it != request->devices.end(); ++device_it) {
       GetDeviceManager(device_it->device.type)->Close(device_it->session_id);
     }
-    if (request->type == MEDIA_GENERATE_STREAM &&
+    if (request->request.request_type == MEDIA_GENERATE_STREAM &&
         RequestDone(*request)) {
       // Notify observers that this device is being closed.
       for (int i = MEDIA_NO_SERVICE + 1; i != NUM_MEDIA_TYPES; ++i) {
         if (request->state(static_cast<MediaStreamType>(i)) !=
             MEDIA_REQUEST_STATE_NOT_REQUESTED) {
           request->SetState(static_cast<MediaStreamType>(i),
                             MEDIA_REQUEST_STATE_CLOSING);
         }
       }
-      NotifyUIDevicesClosed(label);
     }
-
-    // If request isn't complete, notify the UI on the cancellation. And it
-    // is also safe to call CancelUIRequest if the request has been done.
-    ui_controller_->CancelUIRequest(label);
   }
 }
 
 std::string MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 16 matching lines @@
     options.audio_type = type;
     cache = &audio_enumeration_cache_;
   } else if (type == MEDIA_DEVICE_VIDEO_CAPTURE) {
     options.video_type = type;
     cache = &video_enumeration_cache_;
   } else {
     NOTREACHED();
     return std::string();
   }
 
-  DeviceRequest* request = new DeviceRequest(requester,
-                                             options,
-                                             MEDIA_ENUMERATE_DEVICES,
-                                             render_process_id,
-                                             render_view_id,
-                                             security_origin,
-                                             std::string());
+  MediaStreamRequest stream_request(
+      render_process_id, render_view_id, security_origin,
+      MEDIA_ENUMERATE_DEVICES, std::string(),
+      options.audio_type, options.video_type);
+  DeviceRequest* request = new DeviceRequest(requester, stream_request);
   const std::string& label = AddRequest(request);
 
   if (cache->valid) {
     // Cached device list of this type exists. Just send it out.
     request->SetState(type, MEDIA_REQUEST_STATE_REQUESTED);
 
     // 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(request);
   }
 
   return label;
 }
 
 void MediaStreamManager::StopEnumerateDevices(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
-    DCHECK_EQ(it->second->type, MEDIA_ENUMERATE_DEVICES);
+    DCHECK_EQ(it->second->request.request_type, MEDIA_ENUMERATE_DEVICES);
     // Delete the DeviceRequest.
     scoped_ptr<DeviceRequest> request(it->second);
     RemoveRequest(it);
   }
 }
 
 std::string MediaStreamManager::OpenDevice(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     const std::string& device_id,
     MediaStreamType type,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // Create a new request.
   StreamOptions options;
   if (IsAudioMediaType(type)) {
     options.audio_type = type;
   } else if (IsVideoMediaType(type)) {
     options.video_type = type;
   } else {
     NOTREACHED();
     return std::string();
   }
 
-  DeviceRequest* request = new DeviceRequest(requester,
-                                             options,
-                                             MEDIA_OPEN_DEVICE,
-                                             render_process_id,
-                                             render_view_id,
-                                             security_origin,
-                                             device_id);
+  MediaStreamRequest stream_request(
+      render_process_id, render_view_id, security_origin,
+      MEDIA_OPEN_DEVICE, device_id,
+      options.audio_type, options.video_type);
+  DeviceRequest* request = new DeviceRequest(requester, stream_request);
   const std::string& label = AddRequest(request);
   StartEnumeration(request);
 
   return label;
 }
 
-void MediaStreamManager::NotifyUIDevicesOpened(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ui_controller_->NotifyUIIndicatorDevicesOpened(label);
-}
-
-void MediaStreamManager::NotifyUIDevicesClosed(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ui_controller_->NotifyUIIndicatorDevicesClosed(label);
-}
-
 void MediaStreamManager::SendCachedDeviceList(
     EnumerationCache* cache,
     const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (cache->valid) {
     DeviceRequests::iterator it = requests_.find(label);
     if (it != requests_.end()) {
       it->second->requester->DevicesEnumerated(label, cache->devices);
     }
   }
@@ skipping 36 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Start monitoring the devices when doing the first enumeration.
   if (!monitoring_started_ && base::SystemMonitor::Get()) {
     StartMonitoring();
   }
 
   // Start enumeration for devices of all requested device types.
   for (int i = MEDIA_NO_SERVICE + 1; i < NUM_MEDIA_TYPES; ++i) {
     const MediaStreamType stream_type = static_cast<MediaStreamType>(i);
-    if (Requested(request->options, stream_type)) {
+    if (Requested(request->request, stream_type)) {
       request->SetState(stream_type, MEDIA_REQUEST_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(stream_type);
       }
     }
   }
 }
 
 std::string MediaStreamManager::AddRequest(DeviceRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a label for this request and verify it is unique.
   std::string unique_label;
   do {
     unique_label = RandomLabel();
   } while (requests_.find(unique_label) != requests_.end());
 
   requests_.insert(std::make_pair(unique_label, request));
 
   return unique_label;
 }
 
 void MediaStreamManager::RemoveRequest(DeviceRequests::iterator it) {
-  if (it->second->options.video_type == MEDIA_SCREEN_VIDEO_CAPTURE) {
+  if (it->second->request.video_type == MEDIA_SCREEN_VIDEO_CAPTURE) {
     DCHECK(screen_capture_active_);
     screen_capture_active_ = false;
   }
 
-  NotifyUIDevicesClosed(it->first);
-
   requests_.erase(it);
 }
 
 void MediaStreamManager::PostRequestToUI(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequest* request = requests_[label];
-  // Get user confirmation to use capture devices.
-  ui_controller_->MakeUIRequest(label,
-                                request->render_process_id,
-                                request->render_view_id,
-                                request->options,
-                                request->security_origin,
-                                request->type,
-                                request->requested_device_id);
+
+  if (use_fake_ui_) {
+    if (!fake_ui_)
+      fake_ui_.reset(new FakeMediaStreamUIProxy());
+    request->ui_proxy = fake_ui_.Pass();
+  } else {
+    request->ui_proxy.reset(new MediaStreamUIProxy());
+  }
+
+  request->ui_proxy->RequestAccess(
+      request->request,
+      base::Bind(&MediaStreamManager::HandleAccessRequestResponse,
+                 base::Unretained(this), label));
 }
 
 void MediaStreamManager::HandleRequest(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequest* request = requests_[label];
 
-  const MediaStreamType audio_type = request->options.audio_type;
-  const MediaStreamType video_type = request->options.video_type;
+  const MediaStreamType audio_type = request->request.audio_type;
+  const MediaStreamType video_type = request->request.video_type;
 
   bool is_web_contents_capture =
       audio_type == MEDIA_TAB_AUDIO_CAPTURE ||
       video_type == MEDIA_TAB_VIDEO_CAPTURE;
 
   bool is_screen_capure =
       video_type == MEDIA_SCREEN_VIDEO_CAPTURE;
 
   if (!is_web_contents_capture &&
       !is_screen_capure &&
@@ skipping 81 matching lines @@
     }
   }
 
   request->SetState(stream_type, MEDIA_REQUEST_STATE_DONE);
 
   if (!RequestDone(*request)) {
     // This stream_type is done, but not the other type.
     return;
   }
 
-  switch (request->type) {
+  switch (request->request.request_type) {
     case MEDIA_OPEN_DEVICE:
       request->requester->DeviceOpened(label, devices->front());
       break;
     case MEDIA_GENERATE_STREAM: {
       // Partition the array of devices into audio vs video.
       StreamDeviceInfoArray audio_devices, video_devices;
       for (StreamDeviceInfoArray::iterator device_it = devices->begin();
            device_it != devices->end(); ++device_it) {
         if (IsAudioMediaType(device_it->device.type)) {
           // Store the native audio parameters in the device struct.
           // TODO(xians): Handle the tab capture sample rate/channel layout
           // in AudioInputDeviceManager::Open().
           if (device_it->device.type != content::MEDIA_TAB_AUDIO_CAPTURE) {
             const StreamDeviceInfo* info =
                 audio_input_device_manager_->GetOpenedDeviceInfoById(
                     device_it->session_id);
             DCHECK_EQ(info->device.id, device_it->device.id);
             device_it->device.sample_rate = info->device.sample_rate;
             device_it->device.channel_layout = info->device.channel_layout;
           }
           audio_devices.push_back(*device_it);
         } else if (IsVideoMediaType(device_it->device.type)) {
           video_devices.push_back(*device_it);
         } else {
           NOTREACHED();
         }
       }
 
       request->requester->StreamGenerated(label, audio_devices, video_devices);
-      NotifyUIDevicesOpened(label);
+      request->ui_proxy->OnStarted(
+          base::Bind(&MediaStreamManager::StopStreamFromUI,
+                     base::Unretained(this), label));
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 void MediaStreamManager::Closed(MediaStreamType stream_type,
                                 int capture_session_id) {
@@ skipping 21 matching lines @@
   if (need_update_clients && monitoring_started_)
     NotifyDevicesChanged(stream_type, devices);
 
   // 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) ==
-        MEDIA_REQUEST_STATE_REQUESTED &&
-        Requested(it->second->options, stream_type)) {
-      if (it->second->type != MEDIA_ENUMERATE_DEVICES)
+    if (it->second->state(stream_type) == MEDIA_REQUEST_STATE_REQUESTED &&
+        Requested(it->second->request, stream_type)) {
+      if (it->second->request.request_type != MEDIA_ENUMERATE_DEVICES)
         it->second->SetState(stream_type, MEDIA_REQUEST_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) {
+    switch (request->request.request_type) {
       case MEDIA_ENUMERATE_DEVICES:
         if (need_update_clients && request->requester)
           request->requester->DevicesEnumerated(*it, devices);
         break;
       default:
-        if (request->state(request->options.audio_type) ==
+        if (request->state(request->request.audio_type) ==
                 MEDIA_REQUEST_STATE_REQUESTED ||
-            request->state(request->options.video_type) ==
+            request->state(request->request.video_type) ==
                 MEDIA_REQUEST_STATE_REQUESTED) {
           // We are doing enumeration for other type of media, wait until it is
           // all done before posting the request to UI because UI needs
           // the device lists to handle the request.
           break;
         }
 
         // Post the request to UI for permission approval.
         PostRequestToUI(*it);
         break;
@@ skipping 51 matching lines @@
           // 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!
         }
       }
       return;
     }
   }
 }
 
-void MediaStreamManager::DevicesAccepted(const std::string& label,
-                                         const StreamDeviceInfoArray& devices) {
+void MediaStreamManager::HandleAccessRequestResponse(
+    const std::string& label,
+    const MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!devices.empty());
+
   DeviceRequests::iterator request_it = requests_.find(label);
   if (request_it == requests_.end()) {
     return;
   }
 
-  if (request_it->second->type == MEDIA_DEVICE_ACCESS) {
+  // Handle the case when the request was denied.
+  if (devices.empty()) {
+    // Notify the users about the request result.
     scoped_ptr<DeviceRequest> request(request_it->second);
-    if (!request->callback.is_null()) {
-      // Map the devices to MediaStreamDevices.
-      MediaStreamDevices selected_devices;
-      for (StreamDeviceInfoArray::const_iterator it = devices.begin();
-           it != devices.end(); ++it) {
-        selected_devices.push_back(it->device);
-      }
+    if (request->requester)
+      request->requester->StreamGenerationFailed(label);
 
-      request->callback.Run(label, selected_devices);
+    if (request->request.request_type == MEDIA_DEVICE_ACCESS &&
+        !request->callback.is_null()) {
+      request->callback.Run(MediaStreamDevices(), request->ui_proxy.Pass());
     }
 
+    RemoveRequest(request_it);
+    return;
+  }
+
+  if (request_it->second->request.request_type == MEDIA_DEVICE_ACCESS) {
+    scoped_ptr<DeviceRequest> request(request_it->second);
+    if (!request->callback.is_null())
+      request->callback.Run(devices, request->ui_proxy.Pass());
+
     // Delete the request since it is done.
     RemoveRequest(request_it);
     return;
   }
 
   // Process all newly-accepted devices for this request.
   DeviceRequest* request = request_it->second;
-  bool found_audio = false, found_video = false;
-  for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
+  bool found_audio = false;
+  bool found_video = false;
+  for (MediaStreamDevices::const_iterator device_it = devices.begin();
        device_it != devices.end(); ++device_it) {
-    StreamDeviceInfo device_info = *device_it;  // Make a copy.
+    StreamDeviceInfo device_info;
+    device_info.device = *device_it;
 
     // TODO(justinlin): Nicer way to do this?
     // Re-append the device's id since we lost it when posting request to UI.
     if (device_info.device.type == content::MEDIA_TAB_VIDEO_CAPTURE ||
         device_info.device.type == content::MEDIA_TAB_AUDIO_CAPTURE) {
-      device_info.device.id = request->requested_device_id;
+      device_info.device.id = request->request.requested_device_id;
 
       // Initialize the sample_rate and channel_layout here since for audio
       // mirroring, we don't go through EnumerateDevices where these are usually
       // initialized.
       if (device_info.device.type == content::MEDIA_TAB_AUDIO_CAPTURE) {
         const media::AudioParameters parameters =
             audio_manager_->GetDefaultOutputStreamParameters();
         int sample_rate = parameters.sample_rate();
         // If we weren't able to get the native sampling rate or the sample_rate
         // is outside the valid range for input devices set reasonable defaults.
         if (sample_rate <= 0 || sample_rate > 96000)
           sample_rate = 44100;
 
         device_info.device.sample_rate = sample_rate;
         device_info.device.channel_layout = media::CHANNEL_LAYOUT_STEREO;
       }
     }
 
     // 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->device.type),
-              MEDIA_REQUEST_STATE_PENDING_APPROVAL);
     device_info.in_use = false;
 
     device_info.session_id =
         GetDeviceManager(device_info.device.type)->Open(device_info);
-    request->SetState(device_it->device.type, MEDIA_REQUEST_STATE_OPENING);
+    request->SetState(device_info.device.type, MEDIA_REQUEST_STATE_OPENING);
     request->devices.push_back(device_info);
 
-    if (device_info.device.type == request->options.audio_type) {
+    if (device_info.device.type == request->request.audio_type) {
       found_audio = true;
-    } else if (device_info.device.type == request->options.video_type) {
+    } else if (device_info.device.type == request->request.video_type) {
       found_video = true;
     }
   }
 
   // Check whether we've received all stream types requested.
-  if (!found_audio && IsAudioMediaType(request->options.audio_type))
-    request->SetState(request->options.audio_type, MEDIA_REQUEST_STATE_ERROR);
+  if (!found_audio && IsAudioMediaType(request->request.audio_type))
+    request->SetState(request->request.audio_type, MEDIA_REQUEST_STATE_ERROR);
 
-  if (!found_video && IsVideoMediaType(request->options.video_type))
-    request->SetState(request->options.video_type, MEDIA_REQUEST_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())
-    return;
-
-  // Notify the users about the request result.
-  scoped_ptr<DeviceRequest> request(it->second);
-  if (request->requester)
-    request->requester->StreamGenerationFailed(label);
-
-  if (request->type == MEDIA_DEVICE_ACCESS &&
-      !request->callback.is_null()) {
-    request->callback.Run(label, MediaStreamDevices());
-  }
-
-  RemoveRequest(it);
+  if (!found_video && IsVideoMediaType(request->request.video_type))
+    request->SetState(request->request.video_type, MEDIA_REQUEST_STATE_ERROR);
 }
 
 void MediaStreamManager::StopStreamFromUI(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it == requests_.end())
     return;
 
   // Notify renderers that the stream has been stopped.
   if (it->second->requester)
     it->second->requester->StreamGenerationFailed(label);
 
   StopGeneratedStream(label);
 }
 
-void MediaStreamManager::GetAvailableDevices(MediaStreamDevices* devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(audio_enumeration_cache_.valid || video_enumeration_cache_.valid);
-  DCHECK(devices->empty());
-  if (audio_enumeration_cache_.valid) {
-    for (StreamDeviceInfoArray::const_iterator it =
-             audio_enumeration_cache_.devices.begin();
-         it != audio_enumeration_cache_.devices.end();
-         ++it) {
-      devices->push_back(it->device);
-    }
-  }
-
-  if (video_enumeration_cache_.valid) {
-    for (StreamDeviceInfoArray::const_iterator it =
-             video_enumeration_cache_.devices.begin();
-         it != video_enumeration_cache_.devices.end();
-         ++it) {
-      devices->push_back(it->device);
-    }
-  }
-}
-
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   video_capture_manager()->UseFakeDevice();
   audio_input_device_manager()->UseFakeDevice();
-  UseFakeUI(scoped_ptr<MediaStreamUI>());
+  UseFakeUI(scoped_ptr<MediaStreamUIProxy>());
 }
 
-void MediaStreamManager::UseFakeUI(scoped_ptr<MediaStreamUI> fake_ui) {
-  ui_controller_->UseFakeUI(fake_ui.Pass());
+void MediaStreamManager::UseFakeUI(scoped_ptr<MediaStreamUIProxy> fake_ui) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  use_fake_ui_ = true;
+  fake_ui_ = fake_ui.Pass();
 }
 
 void MediaStreamManager::WillDestroyCurrentMessageLoop() {
   DCHECK_EQ(MessageLoop::current(), io_loop_);
   DCHECK(requests_.empty());
   if (device_thread_.get()) {
     StopMonitoring();
 
     video_capture_manager_->Unregister();
     audio_input_device_manager_->Unregister();
     device_thread_.reset();
   }
 
   audio_input_device_manager_ = NULL;
   video_capture_manager_ = NULL;
   io_loop_ = NULL;
-  ui_controller_.reset();
 }
 
 void MediaStreamManager::NotifyDevicesChanged(
     MediaStreamType stream_type,
     const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   MediaObserver* media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer == NULL)
     return;
@@ skipping 10 matching lines @@
   } else if (IsVideoMediaType(stream_type)) {
     media_observer->OnVideoCaptureDevicesChanged(new_devices);
   } else {
     NOTREACHED();
   }
 }
 
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  const bool requested_audio = IsAudioMediaType(request.options.audio_type);
-  const bool requested_video = IsVideoMediaType(request.options.video_type);
+  const bool requested_audio = IsAudioMediaType(request.request.audio_type);
+  const bool requested_video = IsVideoMediaType(request.request.video_type);
 
   const bool audio_done =
       !requested_audio ||
-      request.state(request.options.audio_type) ==
+      request.state(request.request.audio_type) ==
       MEDIA_REQUEST_STATE_DONE ||
-      request.state(request.options.audio_type) ==
+      request.state(request.request.audio_type) ==
       MEDIA_REQUEST_STATE_ERROR;
   if (!audio_done)
     return false;
 
   const bool video_done =
       !requested_video ||
-      request.state(request.options.video_type) ==
+      request.state(request.request.video_type) ==
       MEDIA_REQUEST_STATE_DONE ||
-      request.state(request.options.video_type) ==
+      request.state(request.request.video_type) ==
       MEDIA_REQUEST_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 28 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
 }
 
 }  // namespace content