Pass camera facing to WebKit

media/capture/video/linux/camera_facing_chromeos.cc

 // Copyright 2016 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 "camera_facing_chromeos.h"
 
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/strings/stringprintf.h>
 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_piece.h>
 #include <base/strings/string_split.h>
 #include <base/strings/string_util.h>
 
 namespace media {
 
 namespace {
 
+// The value for each field in the enum matches the value in
+// /etc/camera/camera_characteristics.conf.
+enum LensFacing { FRONT = 0, BACK = 1 };
+
 bool GetCameraId(const base::StringPiece& sub_key, int* camera_id) {
   const base::StringPiece camera_id_prefix = "camera";
   if (!sub_key.starts_with(camera_id_prefix))
     return false;
   return base::StringToInt(sub_key.substr(camera_id_prefix.size()), camera_id);
 }
 }
 
 // /etc/camera/camera_characteristics.conf contains camera information which
 // driver cannot provide.
 static const char kCameraCharacteristicsConfigFile[] =
     "/etc/camera/camera_characteristics.conf";
 static const char kLensFacing[] = "lens_facing";
 static const char kUsbVidPid[] = "usb_vid_pid";
 static const char kUsbPath[] = "usb_path";
 
 CameraFacingChromeOS::CameraFacingChromeOS() {
   InitializeDeviceInfo(std::string(kCameraCharacteristicsConfigFile));
 }
 
 CameraFacingChromeOS::CameraFacingChromeOS(
     const std::string& config_file_path) {
   InitializeDeviceInfo(config_file_path);
 }
 
 CameraFacingChromeOS::~CameraFacingChromeOS() {}
 
-CameraFacingChromeOS::LensFacing CameraFacingChromeOS::GetCameraFacing(
+VideoFacingMode CameraFacingChromeOS::GetCameraFacing(
     const std::string& device_id,
     const std::string& model_id) const {
   std::string usb_id = GetUsbId(device_id);
   const auto& usb_id_to_camera_id_const = usb_id_to_camera_id_;
   const auto& model_id_to_camera_id_const = model_id_to_camera_id_;
   const auto& camera_id_to_facing_const = camera_id_to_facing_;
   auto usb_id_iter = usb_id_to_camera_id_const.find(usb_id);
   int camera_id;
   if (usb_id_iter == usb_id_to_camera_id_const.end()) {
     // Can't find Usb ID. Fall back to use model_id.
@@ skipping 92 matching lines @@
     }
 
     if (sub_keys.size() == 2 && sub_keys[1] == kLensFacing) {
       int lens_facing = -1;
       if (!base::StringToInt(value, &lens_facing)) {
         DLOG(ERROR) << "Invalid value for lens_facing: " << value;
         continue;
       }
       switch (lens_facing) {
         case LensFacing::FRONT:
-          camera_id_to_facing_[camera_id] = LensFacing::FRONT;
+          camera_id_to_facing_[camera_id] =
+              VideoFacingMode::MEDIA_VIDEO_FACING_USER;
           break;
         case LensFacing::BACK:
-          camera_id_to_facing_[camera_id] = LensFacing::BACK;
+          camera_id_to_facing_[camera_id] =
+              VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT;
           break;
         default:
           DLOG(ERROR) << "Invalid value for lens_facing: " << lens_facing;
           continue;
       }
     } else if (sub_keys.size() == 3 && sub_keys[2] == kUsbVidPid) {
       if (value.empty()) {
         DLOG(ERROR) << "model_id is empty";
         continue;
       }
       std::string model_id = value.as_string();
       std::transform(model_id.begin(), model_id.end(), model_id.begin(),
                      ::tolower);
       model_id_to_camera_id_[model_id] = camera_id;
     } else if (sub_keys.size() == 3 && sub_keys[2] == kUsbPath) {
       if (value.empty()) {
         DLOG(ERROR) << "usb_path is empty";
         continue;
       }
       usb_id_to_camera_id_[value.as_string()] = camera_id;
     }
     // Ignore unknown or unutilized attributes.
   }
 }
 
 }  // namespace media