Move ensure keyboard mic check in MediaStreamManager to SetupRequest.

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 <vector>
 
 #include "base/bind.h"
@@ skipping 1064 matching lines @@
   // If the cache isn't valid, we need to start a full enumeration.
   return !cache->valid;
 }
 
 void MediaStreamManager::StartEnumeration(DeviceRequest* request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Start monitoring the devices when doing the first enumeration.
   StartMonitoring();
 
-#if defined(OS_CHROMEOS)
-  if (!has_checked_keyboard_mic_) {
-    has_checked_keyboard_mic_ = true;
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&MediaStreamManager::CheckKeyboardMicOnUIThread,
-                   base::Unretained(this)));
-  }
-#endif
-
   // Start enumeration for devices of all requested device types.
   const MediaStreamType streams[] = { request->audio_type(),
                                       request->video_type() };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(streams); ++i) {
     if (streams[i] == MEDIA_NO_SERVICE)
       continue;
     request->SetState(streams[i], MEDIA_REQUEST_STATE_REQUESTED);
     DCHECK_GE(active_enumeration_ref_count_[streams[i]], 0);
     if (active_enumeration_ref_count_[streams[i]] == 0) {
       ++active_enumeration_ref_count_[streams[i]];
@@ skipping 122 matching lines @@
 
   bool is_screen_capture =
       video_type == MEDIA_DESKTOP_VIDEO_CAPTURE;
   if (is_screen_capture && !SetupScreenCaptureRequest(request)) {
     FinalizeRequestFailed(label,
                           request,
                           MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE);
     return;
   }
 
+#if defined(OS_CHROMEOS)
+  EnsureKeyboardMicChecked();
+#endif
+
   if (!is_web_contents_capture && !is_screen_capture) {
     if (EnumerationRequired(&audio_enumeration_cache_, audio_type) ||
         EnumerationRequired(&video_enumeration_cache_, video_type)) {
       // Enumerate the devices if there is no valid device lists to be used.
       StartEnumeration(request);
       return;
     } else {
         // Cache is valid, so log the cached devices for MediaStream requests.
       if (request->request_type == MEDIA_GENERATE_STREAM) {
         std::string log_message("Using cached devices for request.\n");
@@ skipping 844 matching lines @@
       if (it->device.type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
         video_capture_manager_->SetDesktopCaptureWindowId(it->session_id,
                                                           window_id);
         break;
       }
     }
   }
 }
 
 #if defined(OS_CHROMEOS)
+void MediaStreamManager::EnsureKeyboardMicChecked() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!has_checked_keyboard_mic_) {
+    has_checked_keyboard_mic_ = true;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&MediaStreamManager::CheckKeyboardMicOnUIThread,
+                   base::Unretained(this)));
+  }
+}
+
 void MediaStreamManager::CheckKeyboardMicOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // We will post this on the device thread before the media media access
   // request is posted on the UI thread, so setting the keyboard mic info will
   // be done before any stream is created.
   if (chromeos::CrasAudioHandler::Get()->HasKeyboardMic()) {
     device_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MediaStreamManager::SetKeyboardMicOnDeviceThread,
                    base::Unretained(this)));
   }
 }
 
 void MediaStreamManager::SetKeyboardMicOnDeviceThread() {
   DCHECK(device_task_runner_->BelongsToCurrentThread());
   audio_manager_->SetHasKeyboardMic();
 }
 #endif
 
 }  // namespace content