Add IPC to query capabilities of video input devices.

content/browser/media/media_devices_util.cc

+// Copyright 2017 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/media/media_devices_util.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_tokenizer.h"
+#include "content/browser/frame_host/render_frame_host_delegate.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/media_stream_request.h"
+#include "media/base/media_switches.h"
+
+namespace content {
+
+namespace {
+
+std::string GetDefaultMediaDeviceIDOnUIThread(MediaDeviceType device_type,
+                                              int render_process_id,
+                                              int render_frame_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RenderFrameHostImpl* frame_host =
+      RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
+  if (!frame_host)
+    return std::string();
+
+  RenderFrameHostDelegate* delegate = frame_host->delegate();
+  if (!delegate)
+    return std::string();
+
+  MediaStreamType media_stream_type;
+  switch (device_type) {
+    case MEDIA_DEVICE_TYPE_AUDIO_INPUT:
+      media_stream_type = MEDIA_DEVICE_AUDIO_CAPTURE;
+      break;
+    case MEDIA_DEVICE_TYPE_VIDEO_INPUT:
+      media_stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
+      break;
+    default:
+      return std::string();
+  }
+
+  return delegate->GetDefaultMediaDeviceID(media_stream_type);
+}
+
+std::string GetDefaultMediaDeviceIDFromCommandLine(

[clamy, 2017/01/27 16:44:34]

When is this supposed to be used?

[Guido Urdaneta, 2017/01/27 17:02:14]

It is used when the kUseFakeDeviceForMediaStream command-line switch is passed.
See line 96.
Unit tests often use this switch. In this CL, MediaDevicesDispatcherHostTest
uses this switch and exercises this code.

[clamy, 2017/01/27 17:05:47]

If this is meant to be used in test, then I'd suggest making it explicit in the
function name that this is meant to be used for testing.

[Guido Urdaneta, 2017/01/27 17:14:44]

If I use a "ForTesting" suffix, I get the following warning from the presubmit
script:
  You might be calling functions intended only for testing from
  production code.  It is OK to ignore this warning if you know what
  you are doing, as the heuristics used to detect the situation are
  not perfect.  The commit queue will not block on this warning.
    content/browser/media/media_devices_util.cc:95
      callback.Run(GetDefaultMediaDeviceIDForTesting(device_type));

It won't actually be called unless one passes the command-line switch.
I guess it's OK to ignore the warning. Are you OK with that too?

[clamy, 2017/01/27 17:16:14]

Acknowledged.

[Guido Urdaneta, 2017/01/27 17:17:51]

So, should I proceed with the rename?

[clamy, 2017/01/27 17:19:15]

No it's ok without. You could add a comment that explains it's used in tests
though :).

+    MediaDeviceType device_type) {
+  DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUseFakeDeviceForMediaStream));
+  const std::string option =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kUseFakeDeviceForMediaStream);
+  // Optional comma delimited parameters to the command line can specify values
+  // for the default device IDs.
+  // Examples: "video-input-default-id=mycam, audio-input-default-id=mymic"
+  base::StringTokenizer option_tokenizer(option, ", ");
+  option_tokenizer.set_quote_chars("\"");
+
+  while (option_tokenizer.GetNext()) {
+    std::vector<std::string> param =
+        base::SplitString(option_tokenizer.token(), "=", base::TRIM_WHITESPACE,
+                          base::SPLIT_WANT_NONEMPTY);
+    if (param.size() != 2u) {
+      DLOG(WARNING) << "Forgot a value '" << option << "'? Use name=value for "
+                    << switches::kUseFakeDeviceForMediaStream << ".";
+      return std::string();
+    }
+
+    if (device_type == MEDIA_DEVICE_TYPE_AUDIO_INPUT &&
+        param.front() == "audio-input-default-id") {
+      return param.back();
+    } else if (device_type == MEDIA_DEVICE_TYPE_VIDEO_INPUT &&
+               param.front() == "video-input-default-id") {
+      return param.back();
+    }
+  }
+
+  return std::string();
+}
+
+}  // namespace
+
+void GetDefaultMediaDeviceID(
+    MediaDeviceType device_type,
+    int render_process_id,
+    int render_frame_id,
+    const base::Callback<void(const std::string&)>& callback) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseFakeDeviceForMediaStream)) {
+    callback.Run(GetDefaultMediaDeviceIDFromCommandLine(device_type));
+    return;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&GetDefaultMediaDeviceIDOnUIThread, device_type,
+                 render_process_id, render_frame_id),
+      callback);
+}
+
+}  // namespace content