ppapi/proxy/camera_device_resource.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/camera_device_resource.h"
   6
   7 #include "ppapi/proxy/camera_capabilities_resource.h"
   8 #include "ppapi/proxy/plugin_resource_tracker.h"
   9 #include "ppapi/proxy/ppapi_messages.h"
  10 #include "ppapi/shared_impl/var.h"
  11
  12 namespace ppapi {
  13 namespace proxy {
  14
  15 CameraDeviceResource::CameraDeviceResource(Connection connection,
  16                                            PP_Instance instance)
  17     : PluginResource(connection, instance),
  18       open_state_(OpenState::BEFORE_OPEN) {
  19   SendCreate(RENDERER, PpapiHostMsg_CameraDevice_Create());
  20 }
  21
  22 CameraDeviceResource::~CameraDeviceResource() {
  23 }
  24
  25 int32_t CameraDeviceResource::Open(
  26     PP_Var device_id,
  27     const scoped_refptr<TrackedCallback>& callback) {
  28   if (open_state_ != OpenState::BEFORE_OPEN)
  29     return PP_ERROR_FAILED;
  30
  31   if (TrackedCallback::IsPending(open_callback_))
  32     return PP_ERROR_INPROGRESS;
  33
  34   scoped_refptr<StringVar> source_string_var(StringVar::FromPPVar(device_id));
  35   if (!source_string_var || source_string_var->value().empty())
  36     return PP_ERROR_BADARGUMENT;
  37
  38   open_callback_ = callback;
  39
  40   Call<PpapiPluginMsg_CameraDevice_OpenReply>(
  41       RENDERER, PpapiHostMsg_CameraDevice_Open(source_string_var->value()),
  42       base::Bind(&CameraDeviceResource::OnPluginMsgOpenReply,
  43                  base::Unretained(this)));
  44   return PP_OK_COMPLETIONPENDING;
  45 }
  46
  47 void CameraDeviceResource::Close() {
  48   if (open_state_ == OpenState::CLOSED)
  49     return;
  50
  51   if (TrackedCallback::IsPending(open_callback_)) {
  52     open_callback_->PostAbort();
  53     open_callback_ = nullptr;
  54   }
  55
  56   if (TrackedCallback::IsPending(get_capabilities_callback_)) {
  57     get_capabilities_callback_->PostAbort();
  58     get_capabilities_callback_ = nullptr;
  59   }
  60
  61   Post(RENDERER, PpapiHostMsg_CameraDevice_Close());
  62
  63   open_state_ = OpenState::CLOSED;
  64 }
  65
  66 int32_t CameraDeviceResource::GetCameraCapabilities(
  67     PP_Resource* capabilities,
  68     const scoped_refptr<TrackedCallback>& callback) {
  69   if (!is_opened())
  70     return PP_ERROR_FAILED;
  71
  72   if (TrackedCallback::IsPending(get_capabilities_callback_))
  73     return PP_ERROR_INPROGRESS;
  74
  75   if (camera_capabilities_.get()) {
  76     *capabilities = camera_capabilities_->GetReference();
  77     return PP_OK;
  78   }
  79
  80   get_capabilities_callback_ = callback;
  81   Call<PpapiPluginMsg_CameraDevice_GetSupportedVideoCaptureFormatsReply>(
  82       RENDERER, PpapiHostMsg_CameraDevice_GetSupportedVideoCaptureFormats(),
  83       base::Bind(&CameraDeviceResource::OnPluginMsgGetVideoCaptureFormatsReply,
  84                  base::Unretained(this), capabilities));
  85
  86   return PP_OK_COMPLETIONPENDING;
  87 }
  88
  89 void CameraDeviceResource::OnPluginMsgOpenReply(
  90     const ResourceMessageReplyParams& params) {
  91   // The callback may have been aborted by Close().
  92   if (TrackedCallback::IsPending(open_callback_)) {
  93     if (open_state_ == OpenState::BEFORE_OPEN && params.result() == PP_OK)
  94       open_state_ = OpenState::OPENED;
  95
  96     open_callback_->Run(params.result());
  97   }
  98 }
  99
 100 void CameraDeviceResource::OnPluginMsgGetVideoCaptureFormatsReply(
 101     PP_Resource* capabilities_output,
 102     const ResourceMessageReplyParams& params,
 103     const std::vector<PP_VideoCaptureFormat>& formats) {
 104   if (!TrackedCallback::IsPending(get_capabilities_callback_))
 105     return;
 106
 107   // Return camera capabilities.
 108   int32_t result = params.result();
 109   scoped_refptr<TrackedCallback> callback;
 110   callback.swap(get_capabilities_callback_);
 111   if (result == PP_OK) {
 112     camera_capabilities_ =
 113         new CameraCapabilitiesResource(pp_instance(), formats);
 114     *capabilities_output = camera_capabilities_->GetReference();
 115   }
 116   callback->Run(result == PP_OK ? PP_OK : PP_ERROR_FAILED);
 117 }
 118
 119 }  // namespace proxy
 120 }  // namespace ppapi