Pass camera facing to WebKit

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/renderer/media/media_stream_video_capturer_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 198 matching lines @@
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) override;
   void StartCapture(const media::VideoCaptureParams& params,
                     const VideoCaptureDeliverFrameCB& new_frame_callback,
                     const RunningCallback& running_callback) override;
   void RequestRefreshFrame() override;
   void MaybeSuspend() override;
   void Resume() override;
   void StopCapture() override;
+  media::CameraFacing GetCameraFacing() const override;
 
  private:
   void OnStateUpdate(VideoCaptureState state);
   void OnDeviceFormatsInUseReceived(const media::VideoCaptureFormats& formats);
   void OnDeviceSupportedFormatsEnumerated(
       const media::VideoCaptureFormats& formats);
 
   // |session_id_| identifies the capture device used for this capture session.
   const media::VideoCaptureSessionId session_id_;
 
+  const VideoFacingMode facing_;
+
   VideoCaptureImplManager* const manager_;
 
   const base::Closure release_device_cb_;
 
   // Indicates if we are capturing generated content, e.g. Tab or Desktop.
   const bool is_content_capture_;
 
   // These two are valid between StartCapture() and StopCapture().
   // |running_call_back_| is run when capture is successfully started, and when
   // it is stopped or error happens.
@@ skipping 10 matching lines @@
   base::WeakPtrFactory<LocalVideoCapturerSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalVideoCapturerSource);
 };
 
 }  // namespace
 
 LocalVideoCapturerSource::LocalVideoCapturerSource(
     const StreamDeviceInfo& device_info)
     : session_id_(device_info.session_id),
+      facing_(device_info.device.video_facing),
       manager_(RenderThreadImpl::current()->video_capture_impl_manager()),
       release_device_cb_(manager_->UseDevice(session_id_)),
       is_content_capture_(IsContentVideoCaptureDevice(device_info)),
       weak_factory_(this) {
   DCHECK(RenderThreadImpl::current());
 }
 
 LocalVideoCapturerSource::~LocalVideoCapturerSource() {
   DCHECK(thread_checker_.CalledOnValidThread());
   release_device_cb_.Run();
@@ skipping 71 matching lines @@
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   // Immediately make sure we don't provide more frames.
   if (!stop_capture_cb_.is_null())
     base::ResetAndReturn(&stop_capture_cb_).Run();
   running_callback_.Reset();
   // Invalidate any potential format enumerations going on.
   formats_enumerated_callback_.Reset();
 }
 
+media::CameraFacing LocalVideoCapturerSource::GetCameraFacing() const {
+  switch (facing_) {
+    case VideoFacingMode::MEDIA_VIDEO_FACING_USER:
+      return media::CameraFacing::FRONT;
+    case VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT:
+      return media::CameraFacing::BACK;
+    default:
+      return media::CameraFacing::DEFAULT;
+  }
+}
+
 void LocalVideoCapturerSource::OnStateUpdate(VideoCaptureState state) {
   DVLOG(3) << __func__ << " state = " << state;
   DCHECK(thread_checker_.CalledOnValidThread());
   if (running_callback_.is_null())
     return;
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
       running_callback_.Run(true);
       break;
 
@@ skipping 73 matching lines @@
     RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       source_(new LocalVideoCapturerSource(device_info)) {
   SetStopCallback(stop_callback);
   SetDeviceInfo(device_info);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
+media::CameraFacing MediaStreamVideoCapturerSource::GetCameraFacing() {
+  return source_->GetCameraFacing();
+}
+
 void MediaStreamVideoCapturerSource::RequestRefreshFrame() {
   source_->RequestRefreshFrame();
 }
 
 void MediaStreamVideoCapturerSource::OnHasConsumers(bool has_consumers) {
   if (has_consumers)
     source_->Resume();
   else
     source_->MaybeSuspend();
 }
@@ skipping 48 matching lines @@
     StopSource();
   }
 }
 
 const char*
 MediaStreamVideoCapturerSource::GetPowerLineFrequencyForTesting() const {
   return kPowerLineFrequency;
 }
 
 }  // namespace content