content/renderer/pepper/pepper_platform_camera_device.cc

// Copyright 2015 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/pepper/pepper_platform_camera_device.h"

#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "content/renderer/media/video_capture_impl_manager.h"
#include "content/renderer/pepper/gfx_conversion.h"
#include "content/renderer/pepper/pepper_camera_device_host.h"
#include "content/renderer/pepper/pepper_media_device_manager.h"
#include "content/renderer/render_frame_impl.h"
#include "content/renderer/render_thread_impl.h"
#include "media/base/bind_to_current_loop.h"

namespace content {

PepperPlatformCameraDevice::PepperPlatformCameraDevice(
    int render_frame_id,
    const std::string& device_id,
    PepperCameraDeviceHost* handler)
    : render_frame_id_(render_frame_id),
      device_id_(device_id),
      session_id_(0),
      handler_(handler),
      pending_open_device_(false),
      pending_open_device_id_(-1),
      weak_factory_(this) {
  // We need to open the device and obtain the label and session ID before
  // initializing.
  PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
  if (device_manager) {
    pending_open_device_id_ = device_manager->OpenDevice(
        PP_DEVICETYPE_DEV_VIDEOCAPTURE, device_id, handler->pp_instance(),
        base::Bind(&PepperPlatformCameraDevice::OnDeviceOpened,
                   weak_factory_.GetWeakPtr()));
    pending_open_device_ = true;
  }
}

void PepperPlatformCameraDevice::GetSupportedVideoCaptureFormats() {
  DCHECK(thread_checker_.CalledOnValidThread());
  VideoCaptureImplManager* manager =
      RenderThreadImpl::current()->video_capture_impl_manager();
  manager->GetDeviceSupportedFormats(
      session_id_,
      media::BindToCurrentLoop(base::Bind(
          &PepperPlatformCameraDevice::OnDeviceSupportedFormatsEnumerated,
          weak_factory_.GetWeakPtr())));
}

void PepperPlatformCameraDevice::DetachEventHandler() {
  DCHECK(thread_checker_.CalledOnValidThread());
  handler_ = nullptr;
  if (!release_device_cb_.is_null()) {
    base::ResetAndReturn(&release_device_cb_).Run();
  }
  if (!label_.empty()) {
    PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
    if (device_manager)
      device_manager->CloseDevice(label_);
    label_.clear();
  }
  if (pending_open_device_) {
    PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
    if (device_manager)
      device_manager->CancelOpenDevice(pending_open_device_id_);
    pending_open_device_ = false;
    pending_open_device_id_ = -1;
  }
}

PepperPlatformCameraDevice::~PepperPlatformCameraDevice() {
  DCHECK(thread_checker_.CalledOnValidThread());
  DCHECK(release_device_cb_.is_null());
  DCHECK(label_.empty());
  DCHECK(!pending_open_device_);
}

void PepperPlatformCameraDevice::OnDeviceOpened(int request_id,
                                                bool succeeded,
                                                const std::string& label) {
  DCHECK(thread_checker_.CalledOnValidThread());
  DCHECK(handler_);

  pending_open_device_ = false;
  pending_open_device_id_ = -1;

  PepperMediaDeviceManager* const device_manager = GetMediaDeviceManager();
  succeeded = succeeded && device_manager;
  if (succeeded) {
    label_ = label;
    session_id_ =
        device_manager->GetSessionID(PP_DEVICETYPE_DEV_VIDEOCAPTURE, label);
    VideoCaptureImplManager* manager =
        RenderThreadImpl::current()->video_capture_impl_manager();
    release_device_cb_ = manager->UseDevice(session_id_);
  }

  handler_->OnInitialized(succeeded);
}

void PepperPlatformCameraDevice::OnDeviceSupportedFormatsEnumerated(
    const media::VideoCaptureFormats& formats) {
  DCHECK(thread_checker_.CalledOnValidThread());
  DCHECK(handler_);

  std::vector<PP_VideoCaptureFormat> output_formats;
  for (const auto& format : formats) {
    PP_VideoCaptureFormat output_format;
    output_format.frame_size = PP_FromGfxSize(format.frame_size);
    output_format.frame_rate = format.frame_rate;
    output_formats.push_back(output_format);
  }
  handler_->OnVideoCaptureFormatsEnumerated(output_formats);
}

PepperMediaDeviceManager* PepperPlatformCameraDevice::GetMediaDeviceManager() {
  RenderFrameImpl* const render_frame =
      RenderFrameImpl::FromRoutingID(render_frame_id_);
  return render_frame
             ? PepperMediaDeviceManager::GetForRenderFrame(render_frame).get()
             : nullptr;
}

}  // namespace content