Remove dead code related to media device enumerations and monitoring.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 137 matching lines @@
     for (const chromeos::AudioDevice& device : devices) {
       if (device.type == chromeos::AUDIO_TYPE_HOTWORD) {
         DCHECK(device.is_input);
         *effects |= media::AudioParameters::HOTWORD;
       }
     }
 #endif
   }
 }
 
-// Clears the MediaStreamDevice.name from all devices in |devices|.
-void ClearDeviceLabels(content::StreamDeviceInfoArray* devices) {
-  for (content::StreamDeviceInfo& device_info : *devices)
-    device_info.device.name.clear();
-}
-
 bool CalledOnIOThread() {
   // Check if this function call is on the IO thread, except for unittests where
   // an IO thread might not have been created.
   return BrowserThread::CurrentlyOn(BrowserThread::IO) ||
          !BrowserThread::IsMessageLoopValid(BrowserThread::IO);
 }
 
 bool GetDeviceIDFromHMAC(const std::string& salt,
                          const url::Origin& security_origin,
                          const std::string& hmac_device_id,
@@ skipping 12 matching lines @@
   }
   return false;
 }
 
 MediaStreamType ConvertToMediaStreamType(MediaDeviceType type) {
   switch (type) {
     case MEDIA_DEVICE_TYPE_AUDIO_INPUT:
       return MEDIA_DEVICE_AUDIO_CAPTURE;
     case MEDIA_DEVICE_TYPE_VIDEO_INPUT:
       return MEDIA_DEVICE_VIDEO_CAPTURE;
-    case MEDIA_DEVICE_TYPE_AUDIO_OUTPUT:
-      return MEDIA_DEVICE_AUDIO_OUTPUT;
     default:
       NOTREACHED();
   }
 
   return MEDIA_NO_SERVICE;
 }
 
 MediaDeviceType ConvertToMediaDeviceType(MediaStreamType stream_type) {
   switch (stream_type) {
     case MEDIA_DEVICE_AUDIO_CAPTURE:
       return MEDIA_DEVICE_TYPE_AUDIO_INPUT;
     case MEDIA_DEVICE_VIDEO_CAPTURE:
       return MEDIA_DEVICE_TYPE_VIDEO_INPUT;
-    case MEDIA_DEVICE_AUDIO_OUTPUT:
-      return MEDIA_DEVICE_TYPE_AUDIO_OUTPUT;
     default:
       NOTREACHED();
   }
 
   return NUM_MEDIA_DEVICE_TYPES;
 }
 
-StreamDeviceInfoArray ConvertToStreamDeviceInfoArray(
-    MediaStreamType stream_type,
-    const MediaDeviceInfoArray& device_infos) {
-  StreamDeviceInfoArray stream_devices;
-  for (const auto& info : device_infos) {
-    stream_devices.emplace_back(stream_type, info.label, info.device_id,
-                                info.group_id);
-  }
-
-  return stream_devices;
-}
-
 MediaStreamDevices ConvertToMediaStreamDevices(
     MediaStreamType stream_type,
     const MediaDeviceInfoArray& device_infos) {
   MediaStreamDevices devices;
   for (const auto& info : device_infos) {
-    devices.emplace_back(stream_type, info.device_id, info.label,
-                         info.group_id);
+    devices.emplace_back(stream_type, info.device_id, info.label);
   }
 
   return devices;
 }
 
 }  // namespace
 
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
 // available devices or open one or more devices.
@@ skipping 24 matching lines @@
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED),
         audio_type_(MEDIA_NO_SERVICE),
         video_type_(MEDIA_NO_SERVICE),
         target_process_id_(-1),
         target_frame_id_(-1) {}
 
   ~DeviceRequest() {}
 
   void SetAudioType(MediaStreamType audio_type) {
     DCHECK(IsAudioInputMediaType(audio_type) ||
-           audio_type == MEDIA_DEVICE_AUDIO_OUTPUT ||
            audio_type == MEDIA_NO_SERVICE);
     audio_type_ = audio_type;
   }
 
   MediaStreamType audio_type() const { return audio_type_; }
 
   void SetVideoType(MediaStreamType video_type) {
     DCHECK(IsVideoMediaType(video_type) || video_type == MEDIA_NO_SERVICE);
     video_type_ = video_type;
   }
@@ skipping 158 matching lines @@
   // MediaStreamManager, but power_monitor may be NULL in unit tests.
   if (power_monitor)
     power_monitor->AddObserver(this);
 }
 
 MediaStreamManager::~MediaStreamManager() {
   DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::IO));
   DVLOG(1) << "~MediaStreamManager";
   DCHECK(requests_.empty());
   DCHECK(!device_task_runner_.get());
-  DCHECK(device_change_subscribers_.empty());
 
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   // The PowerMonitor instance owned by BrowserMainLoops always outlives the
   // MediaStreamManager, but it may be NULL in unit tests.
   if (power_monitor)
     power_monitor->RemoveObserver(this);
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 104 matching lines @@
 void MediaStreamManager::CancelRequest(const std::string& label) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "CancelRequest({label = " << label <<  "})";
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     // The request does not exist.
     LOG(ERROR) << "The request with label = " << label  << " does not exist.";
     return;
   }
 
-  if (request->request_type == MEDIA_ENUMERATE_DEVICES) {
-    // It isn't an ideal use of "CancelRequest" to make it a requirement
-    // for enumeration requests to be deleted via "CancelRequest" _after_
-    // the request has been successfully fulfilled.
-    // See note in FinalizeEnumerateDevices for a recommendation on how
-    // we should refactor this.
-    DeleteRequest(label);
-    return;
-  }
-
   // This is a request for opening one or more devices.
   for (const StreamDeviceInfo& device_info : request->devices) {
     const MediaRequestState state = request->state(device_info.device.type);
     // If we have not yet requested the device to be opened - just ignore it.
     if (state != MEDIA_REQUEST_STATE_OPENING &&
         state != MEDIA_REQUEST_STATE_DONE) {
       continue;
     }
     // Stop the opening/opened devices of the requests.
     CloseDevice(device_info.device.type, device_info.session_id);
@@ skipping 110 matching lines @@
       if (device_info.session_id == session_id &&
           device_info.device.type == type) {
         // Notify observers that this device is being closed.
         // Note that only one device per type can be opened.
         request->SetState(type, MEDIA_REQUEST_STATE_CLOSING);
       }
     }
   }
 }
 
-std::string MediaStreamManager::EnumerateDevices(
-    MediaStreamRequester* requester,
-    int render_process_id,
-    int render_frame_id,
-    const std::string& salt,
-    int page_request_id,
-    MediaStreamType type,
-    const url::Origin& security_origin) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(requester);
-  DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
-         type == MEDIA_DEVICE_VIDEO_CAPTURE ||
-         type == MEDIA_DEVICE_AUDIO_OUTPUT);
-
-  DeviceRequest* request =
-      new DeviceRequest(requester, render_process_id, render_frame_id,
-                        page_request_id, security_origin,
-                        false,  // user gesture
-                        MEDIA_ENUMERATE_DEVICES, StreamControls(), salt);
-  if (IsAudioInputMediaType(type) || type == MEDIA_DEVICE_AUDIO_OUTPUT)
-    request->SetAudioType(type);
-  else if (IsVideoMediaType(type))
-    request->SetVideoType(type);
-
-  const std::string& label = AddRequest(request);
-  // Post a task and handle the request asynchronously. The reason is that the
-  // requester won't have a label for the request until this function returns
-  // and thus can not handle a response. Using base::Unretained is safe since
-  // MediaStreamManager is deleted on the UI thread, after the IO thread has
-  // been stopped.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaStreamManager::DoEnumerateDevices,
-                 base::Unretained(this), label));
-  return label;
-}
-
-void MediaStreamManager::DoEnumerateDevices(const std::string& label) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DeviceRequest* request = FindRequest(label);
-  if (!request)
-    return;  // This can happen if the request has been canceled.
-
-  if (request->audio_type() == MEDIA_DEVICE_AUDIO_OUTPUT) {
-    DCHECK_EQ(MEDIA_NO_SERVICE, request->video_type());
-    request->SetState(MEDIA_DEVICE_AUDIO_OUTPUT, MEDIA_REQUEST_STATE_REQUESTED);
-    MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
-    devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
-    media_devices_manager_->EnumerateDevices(
-        devices_to_enumerate,
-        base::Bind(&MediaStreamManager::AudioOutputDevicesEnumerated,
-                   base::Unretained(this), label));
-    return;
-  }
-
-  StartEnumeration(request, label);
-  DVLOG(1) << "Enumerate Devices ({label = " << label <<  "})";
-}
-
-void MediaStreamManager::AudioOutputDevicesEnumerated(
-    const std::string& label,
-    const MediaDeviceEnumeration& enumeration) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  DeviceRequest* request = FindRequest(label);
-  if (!request)
-    return;
-
-  DCHECK_EQ(MEDIA_DEVICE_AUDIO_OUTPUT, request->audio_type());
-  DCHECK_EQ(MEDIA_REQUEST_STATE_REQUESTED,
-            request->state(MEDIA_DEVICE_AUDIO_OUTPUT));
-  DCHECK_EQ(MEDIA_ENUMERATE_DEVICES, request->request_type);
-  DCHECK(!request->ui_proxy.get());
-  StreamDeviceInfoArray device_infos = ConvertToStreamDeviceInfoArray(
-      MEDIA_DEVICE_AUDIO_OUTPUT, enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT]);
-  request->devices = device_infos;
-  FinalizeEnumerateDevices(label, request);
-}
-
 void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
                                     int render_process_id,
                                     int render_frame_id,
                                     const std::string& salt,
                                     int page_request_id,
                                     const std::string& device_id,
                                     MediaStreamType type,
                                     const url::Origin& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
@@ skipping 130 matching lines @@
   } else {
     NOTREACHED();
   }
   return false;
 }
 
 void MediaStreamManager::TranslateDeviceIdToSourceId(
     DeviceRequest* request,
     MediaStreamDevice* device) {
   if (request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
-      request->audio_type() == MEDIA_DEVICE_AUDIO_OUTPUT ||
       request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
     device->id = GetHMACForMediaDeviceID(request->salt,
                                          request->security_origin, device->id);
-    if (!device->group_id.empty())
-      device->group_id = GetHMACForMediaDeviceID(
-          request->salt, request->security_origin, device->group_id);
   }
 }
 
 void MediaStreamManager::StartEnumeration(DeviceRequest* request,
                                           const std::string& label) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Start monitoring the devices when doing the first enumeration.
   media_devices_manager_->StartMonitoring();
 
@@ skipping 99 matching lines @@
 
   // If using the fake UI, it will just auto-select from the available devices.
   // The fake UI doesn't work for desktop sharing requests since we can't see
   // its devices from here; always use the real UI for such requests.
   if (use_fake_ui_ && request->video_type() != MEDIA_DESKTOP_VIDEO_CAPTURE) {
     if (!fake_ui_)
       fake_ui_.reset(new FakeMediaStreamUIProxy());
 
     MediaStreamDevices devices;
     for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
-      devices.emplace_back(audio_type, info.device_id, info.label,
-                           info.group_id);
+      devices.emplace_back(audio_type, info.device_id, info.label);
     }
     for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT]) {
-      devices.emplace_back(video_type, info.device_id, info.label,
-                           info.group_id);
+      devices.emplace_back(video_type, info.device_id, info.label);
     }
 
     fake_ui_->SetAvailableDevices(devices);
 
     request->ui_proxy = std::move(fake_ui_);
   } else {
     request->ui_proxy = MediaStreamUIProxy::Create();
   }
 
   request->ui_proxy->RequestAccess(
@@ skipping 233 matching lines @@
 }
 
 void MediaStreamManager::FinalizeOpenDevice(const std::string& label,
                                             DeviceRequest* request) {
   const StreamDeviceInfoArray& requested_devices = request->devices;
   request->requester->DeviceOpened(request->requesting_frame_id,
                                    request->page_request_id,
                                    label, requested_devices.front());
 }
 
-void MediaStreamManager::FinalizeEnumerateDevices(const std::string& label,
-                                                  DeviceRequest* request) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(request->request_type, MEDIA_ENUMERATE_DEVICES);
-  DCHECK(((request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
-           request->audio_type() == MEDIA_DEVICE_AUDIO_OUTPUT) &&
-          request->video_type() == MEDIA_NO_SERVICE) ||
-         (request->audio_type() == MEDIA_NO_SERVICE &&
-          request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE));
-
-  for (StreamDeviceInfo& device_info : request->devices)
-    TranslateDeviceIdToSourceId(request, &device_info.device);
-
-  if (use_fake_ui_) {
-    if (!fake_ui_)
-      fake_ui_.reset(new FakeMediaStreamUIProxy());
-    request->ui_proxy = std::move(fake_ui_);
-  } else {
-    DCHECK(!request->ui_proxy);
-    request->ui_proxy = MediaStreamUIProxy::Create();
-  }
-
-  // Output label permissions are based on input permission.
-  const MediaStreamType type =
-      request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
-      request->audio_type() == MEDIA_DEVICE_AUDIO_OUTPUT
-      ? MEDIA_DEVICE_AUDIO_CAPTURE
-      : MEDIA_DEVICE_VIDEO_CAPTURE;
-
-  request->ui_proxy->CheckAccess(
-      request->security_origin,
-      type,
-      request->requesting_process_id,
-      request->requesting_frame_id,
-      base::Bind(&MediaStreamManager::HandleCheckMediaAccessResponse,
-                 base::Unretained(this),
-                 label));
-}
-
-void MediaStreamManager::HandleCheckMediaAccessResponse(
-    const std::string& label,
-    bool have_access) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  DeviceRequest* request = FindRequest(label);
-  if (!request) {
-    // This can happen if the request was cancelled.
-    DVLOG(1) << "The request with label " << label << " does not exist.";
-    return;
-  }
-
-  if (!have_access)
-    ClearDeviceLabels(&request->devices);
-
-  request->requester->DevicesEnumerated(
-      request->requesting_frame_id,
-      request->page_request_id,
-      label,
-      request->devices);
-
-  // TODO(guidou):
-  // Ideally enumeration requests should be deleted once they have been served
-  // (as any request).  However, this implementation mixes requests and
-  // notifications together so enumeration requests are kept open by some
-  // implementations (only Pepper?) and enumerations are done again when
-  // device notifications are fired.
-  // Implementations that just want to request the device list and be done
-  // (e.g. DeviceRequestMessageFilter), they must (confusingly) call
-  // CancelRequest() after the request has been fulfilled.  This is not
-  // obvious, not consistent in this class (see e.g. FinalizeMediaAccessRequest)
-  // and can lead to subtle bugs (requests not deleted at all deleted too
-  // early).
-  //
-  // Basically, it is not clear that using requests as an additional layer on
-  // top of device notifications is necessary or good.
-  //
-  // To add to this, MediaStreamManager currently relies on the external
-  // implementations of MediaStreamRequester to delete enumeration requests via
-  // CancelRequest and e.g. DeviceRequestMessageFilter does this.  However the
-  // Pepper implementation does not seem to to this at all (and from what I can
-  // see, it is the only implementation that uses an enumeration request as a
-  // notification mechanism).
-  //
-  // We should decouple notifications from enumeration requests and once that
-  // has been done, remove the requirement to call CancelRequest() to delete
-  // enumeration requests and uncomment the following line:
-  //
-  // DeleteRequest(label);
-}
-
 void MediaStreamManager::FinalizeMediaAccessRequest(
     const std::string& label,
     DeviceRequest* request,
     const MediaStreamDevices& devices) {
   if (!request->callback.is_null())
     request->callback.Run(devices, std::move(request->ui_proxy));
 
   // Delete the request since it is done.
   DeleteRequest(label);
 }
@@ skipping 147 matching lines @@
     const MediaDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DeviceRequest* request = FindRequest(label);
   if (!request)
     return;
 
   bool requested[] = {requested_audio_input, requested_video_input};
   MediaStreamType stream_types[] = {MEDIA_DEVICE_AUDIO_CAPTURE,
                                     MEDIA_DEVICE_VIDEO_CAPTURE};
-  MediaDeviceType device_types[] = {MEDIA_DEVICE_TYPE_AUDIO_INPUT,
-                                    MEDIA_DEVICE_TYPE_VIDEO_INPUT};
-
   for (size_t i = 0; i < arraysize(requested); ++i) {
     if (!requested[i])
       continue;
 
     DCHECK(request->audio_type() == stream_types[i] ||
            request->video_type() == stream_types[i]);
     if (request->state(stream_types[i]) == MEDIA_REQUEST_STATE_REQUESTED) {
-      if (request->request_type == MEDIA_ENUMERATE_DEVICES) {
-        // MEDIA_ENUMERATE_DEVICES requests are always for a single type, so it
-        // is OK to ignore any remaining iteration in this loop.
-        ProcessEnumerationRequest(label, request, stream_types[i],
-                                  enumeration[device_types[i]]);
-        return;
-      }
-      // Not a MEDIA_ENUMERATE_DEVICES request.
       request->SetState(stream_types[i], MEDIA_REQUEST_STATE_PENDING_APPROVAL);
     }
   }
 
   if (!SetupDeviceCaptureRequest(request, enumeration))
     FinalizeRequestFailed(label, request, MEDIA_DEVICE_NO_HARDWARE);
   else
     ReadOutputParamsAndPostRequestToUI(label, request, enumeration);
 }
 
@@ skipping 195 matching lines @@
     if (media_observer)
       media_observer->OnAudioCaptureDevicesChanged();
   } else if (IsVideoMediaType(stream_type)) {
     MediaCaptureDevicesImpl::GetInstance()->OnVideoCaptureDevicesChanged(
         new_devices);
     if (media_observer)
       media_observer->OnVideoCaptureDevicesChanged();
   } else {
     NOTREACHED();
   }
-
-  ProcessOpenEnumerationRequests(stream_type, devices);
 }
 
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const bool requested_audio = IsAudioInputMediaType(request.audio_type());
   const bool requested_video = IsVideoMediaType(request.video_type());
 
   const bool audio_done =
       !requested_audio ||
@@ skipping 60 matching lines @@
   // Re-registering (overwriting) is allowed and happens in some tests.
   log_callbacks_[renderer_host_id] = callback;
 }
 
 void MediaStreamManager::DoNativeLogCallbackUnregistration(
     int renderer_host_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   log_callbacks_.erase(renderer_host_id);
 }
 
-void MediaStreamManager::SubscribeToDeviceChangeNotifications(
-    MediaStreamRequester* subscriber) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(subscriber);
-  DCHECK(std::find_if(device_change_subscribers_.begin(),
-                      device_change_subscribers_.end(),
-                      [subscriber](MediaStreamRequester* item) {
-                        return subscriber == item;
-                      }) == device_change_subscribers_.end());
-  device_change_subscribers_.push_back(subscriber);
-}
-
-void MediaStreamManager::CancelDeviceChangeNotifications(
-    MediaStreamRequester* subscriber) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  auto it = std::find(device_change_subscribers_.begin(),
-                      device_change_subscribers_.end(), subscriber);
-  CHECK(it != device_change_subscribers_.end());
-  device_change_subscribers_.erase(it);
-}
-
-void MediaStreamManager::NotifyDeviceChangeSubscribers(MediaStreamType type) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  for (auto* subscriber : device_change_subscribers_)
-    subscriber->DevicesChanged(type);
-}
-
 // static
 std::string MediaStreamManager::GetHMACForMediaDeviceID(
     const std::string& salt,
     const url::Origin& security_origin,
     const std::string& raw_unique_id) {
   DCHECK(!raw_unique_id.empty());
   if (raw_unique_id == media::AudioDeviceDescription::kDefaultDeviceId ||
       raw_unique_id == media::AudioDeviceDescription::kCommunicationsDeviceId) {
     return raw_unique_id;
   }
@@ skipping 45 matching lines @@
     for (const StreamDeviceInfo& device_info : request->devices) {
       if (device_info.session_id == session_id &&
           device_info.device.type == type) {
         request->SetCapturingLinkSecured(is_secure);
         return;
       }
     }
   }
 }
 
-void MediaStreamManager::ProcessEnumerationRequest(
-    const std::string& label,
-    DeviceRequest* request,
-    MediaStreamType stream_type,
-    const MediaDeviceInfoArray& device_infos) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK_EQ(MEDIA_REQUEST_STATE_REQUESTED, request->state(stream_type));
-  DCHECK(request->audio_type() == stream_type ||
-         request->video_type() == stream_type);
-  DCHECK(request->audio_type() == MEDIA_NO_SERVICE ||
-         request->video_type() == MEDIA_NO_SERVICE);
-  DCHECK_EQ(MEDIA_ENUMERATE_DEVICES, request->request_type);
-
-  if (request->requester && !request->ui_proxy) {
-    request->devices =
-        ConvertToStreamDeviceInfoArray(stream_type, device_infos);
-    FinalizeEnumerateDevices(label, request);
-  }
-}
-
-// This function is intended to support subscription-style device enumerations.
-// It is only supported for media capture devices and will be removed once
-// handling of enumeration requests and device-change notifications is migrated
-// out of MediaStreamManager.
-void MediaStreamManager::ProcessOpenEnumerationRequests(
-    MediaStreamType stream_type,
-    const MediaDeviceInfoArray& device_infos) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
-         stream_type == MEDIA_DEVICE_VIDEO_CAPTURE);
-
-  for (const LabeledDeviceRequest& labeled_request : requests_) {
-    DeviceRequest* request = labeled_request.second;
-    if (request->request_type == MEDIA_ENUMERATE_DEVICES &&
-        request->state(stream_type) == MEDIA_REQUEST_STATE_REQUESTED &&
-        (request->audio_type() == stream_type ||
-         request->video_type() == stream_type)) {
-      ProcessEnumerationRequest(labeled_request.first, request, stream_type,
-                                device_infos);
-    }
-  }
-}
-
 void MediaStreamManager::SetGenerateStreamCallbackForTesting(
     GenerateStreamTestCallback test_callback) {
   generate_stream_test_callback_ = test_callback;
 }
 
 }  // namespace content