Pass camera facing to WebKit

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>
 #include <cctype>
 #include <list>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
+#include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_capture_devices_impl.h"
 #include "content/browser/renderer_host/media/media_devices_manager.h"
 #include "content/browser/renderer_host/media/media_stream_requester.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/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 14 matching lines @@
 #include "media/capture/video/video_capture_device_factory.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
+#include "media/capture/video/linux/camera_facing_chromeos.h"
 #endif
 
 namespace content {
 
 base::LazyInstance<base::ThreadLocalPointer<MediaStreamManager>>::Leaky
     g_media_stream_manager_tls_ptr = LAZY_INSTANCE_INITIALIZER;
 
 namespace {
+
+#if defined(OS_CHROMEOS)
+base::LazyInstance<media::CameraFacingChromeOS>::Leaky g_camera_facing =
+    LAZY_INSTANCE_INITIALIZER;

[hta - Chromium, 2017/01/12 19:36:41]

If this is a singleton, does it make the assumption that a ChromeOS device has
only one camera?

If not, how is a ChromeOS device with two cameras represented?
Remember that ChromeOS devices have USB ports; cameras attached there will have
to have facing = "none".

[shenghao, 2017/01/13 11:09:34]

No.
g_camera_facing is a helper class that takes in model_id and/or usb_id and tell
you what facing the device is. Facing information for each device is stored in
MediaStreamDevice. If one chromebook has 2 cameras, then there will be 2
MediaStreamDevice. I rename g_camera_facing to g_camera_facing_helper to make it
more clear.

For externally plugged in cameras,
g_camera_facing_helper.Get().GetCameraFacing() would return NONE.

+#endif
+
 // Creates a random label used to identify requests.
 std::string RandomLabel() {
   // An earlier PeerConnection spec [1] defined MediaStream::label alphabet as
   // an uuid with 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. That causes problems with searching for labels in bots, so we use a
   // safe alphanumeric subset |kAlphabet|.
   // [1] http://dev.w3.org/2011/webrtc/editor/webrtc.html
   static const char kAlphabet[] = "0123456789"
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ skipping 120 matching lines @@
       return MEDIA_DEVICE_TYPE_AUDIO_INPUT;
     case MEDIA_DEVICE_VIDEO_CAPTURE:
       return MEDIA_DEVICE_TYPE_VIDEO_INPUT;
     default:
       NOTREACHED();
   }
 
   return NUM_MEDIA_DEVICE_TYPES;
 }
 
+VideoFacingMode GetVideoFacing(std::string device_id,
+                               std::string model_id,
+                               MediaStreamType stream_type) {
+#if defined(OS_CHROMEOS)
+  media::CameraFacingChromeOS::LensFacing facing =
+      g_camera_facing.Get().GetCameraFacing(device_id, model_id);
+  switch (facing) {
+    case media::CameraFacingChromeOS::LensFacing::FRONT:
+      return VideoFacingMode::MEDIA_VIDEO_FACING_USER;
+    case media::CameraFacingChromeOS::LensFacing::BACK:
+      return VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT;
+  }
+#endif
+  if (IsScreenCaptureMediaType(stream_type)) {
+    return VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT;

[hta - Chromium, 2017/01/12 19:36:41]

How does this choice make sense?

I'd have thought not saying anything (ie none) would be more correct.

[shenghao, 2017/01/13 11:09:34]

done

+  }
+  return VideoFacingMode::MEDIA_VIDEO_FACING_NONE;
+}
+
 MediaStreamDevices ConvertToMediaStreamDevices(
     MediaStreamType stream_type,
     const MediaDeviceInfoArray& device_infos) {
+  base::ThreadRestrictions::SetIOAllowed(true);

[jochen (gone - plz use gerrit), 2017/01/12 11:54:41]

why is this required? how long will the operation block? Should this be done on
a background thread?

[shenghao, 2017/01/13 11:09:34]

Because we need to access camera config file when g_camera_facing is created.
Now I moved it to when VideoCaptureDeviceDescriptor is created, so no need to
access IO here anymore.

   MediaStreamDevices devices;
   for (const auto& info : device_infos) {
-    devices.emplace_back(stream_type, info.device_id, info.label);
+    devices.emplace_back(
+        stream_type, info.device_id, info.label,
+        GetVideoFacing(info.device_id, info.model_id, stream_type));
   }
 
   return devices;
 }
 
 }  // namespace
 
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
 // available devices or open one or more devices.
@@ skipping 1517 matching lines @@
   generate_stream_test_callback_ = test_callback;
 }
 
 #if defined(OS_WIN)
 void MediaStreamManager::FlushVideoCaptureThreadForTesting() {
   video_capture_thread_.FlushForTesting();
 }
 #endif
 
 }  // namespace content