PPAPI: implement GetSupportedPreviewSizes

ppapi/proxy/image_capture_resource.cc

Index: ppapi/proxy/image_capture_resource.cc
diff --git a/ppapi/proxy/image_capture_resource.cc b/ppapi/proxy/image_capture_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e010334a54272a51cbbb725c8e7b54bd6f2e8ea8
--- /dev/null
+++ b/ppapi/proxy/image_capture_resource.cc
@@ -0,0 +1,147 @@
+// 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 "ppapi/proxy/image_capture_resource.h"
+
+#include "ppapi/proxy/camera_capabilities_resource.h"
+#include "ppapi/proxy/plugin_globals.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/ppb_buffer_proxy.h"
+#include "ppapi/shared_impl/proxy_lock.h"
+#include "ppapi/shared_impl/var.h"
+
+namespace ppapi {
+namespace proxy {
+
+ImageCaptureResource::ImageCaptureResource(Connection connection,
+                                           PP_Instance instance)
+    : PluginResource(connection, instance),
+      open_state_(BEFORE_OPEN),
+      get_capabilities_output_(NULL) {
+  SendCreate(RENDERER, PpapiHostMsg_ImageCapture_Create());
+}
+
+ImageCaptureResource::~ImageCaptureResource() {
+}
+
+int32_t ImageCaptureResource::Open(PP_Var camera_source_id,
+                                   scoped_refptr<TrackedCallback> callback) {
+  if (open_state_ != BEFORE_OPEN)
+    return PP_ERROR_FAILED;
+
+  if (TrackedCallback::IsPending(open_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  scoped_refptr<StringVar> source_string_var;
+  source_string_var = StringVar::FromPPVar(camera_source_id);
+  if (!source_string_var || source_string_var->value().empty())
+    return PP_ERROR_BADARGUMENT;
+
+  open_callback_ = callback;
+
+  Call<PpapiPluginMsg_ImageCapture_OpenReply>(
+      RENDERER,
+      PpapiHostMsg_ImageCapture_Open(source_string_var->value()),
+      base::Bind(&ImageCaptureResource::OnPluginMsgOpenReply,
+                 base::Unretained(this)));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void ImageCaptureResource::Close() {
+  if (open_state_ == CLOSED)
+    return;
+
+  if (TrackedCallback::IsPending(open_callback_)) {
+    open_callback_->PostAbort();
+    open_callback_ = NULL;
+  }
+
+  if (TrackedCallback::IsPending(get_capabilities_callback_)) {
+    *get_capabilities_output_ = 0;
+    get_capabilities_callback_->PostAbort();
+    get_capabilities_callback_ = NULL;
+    get_capabilities_output_ = NULL;
+  }
+
+  Post(RENDERER, PpapiHostMsg_ImageCapture_Close());
+
+  open_state_ = CLOSED;
+}
+
+int32_t ImageCaptureResource::SetConfig(
+    PP_Resource config,
+    scoped_refptr<TrackedCallback> callback) {
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t ImageCaptureResource::GetConfig(
+    PP_Resource* config,
+    scoped_refptr<TrackedCallback> callback) {
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t ImageCaptureResource::GetCameraCapabilities(
+    PP_Resource* capabilities,
+    scoped_refptr<TrackedCallback> callback) {
+  if (!IsOpened())
+    return PP_ERROR_FAILED;
+
+  if (TrackedCallback::IsPending(get_capabilities_callback_))
+    return PP_ERROR_INPROGRESS;
+
+  if (camera_capabilities_.get()) {
+    *capabilities = camera_capabilities_->GetReference();
+    return PP_OK;
+  }
+
+  get_capabilities_output_ = capabilities;
+  get_capabilities_callback_ = callback;
+  Call<PpapiPluginMsg_ImageCapture_GetSupportedPreviewSizesReply>(
+      RENDERER,
+      PpapiPluginMsg_ImageCapture_GetSupportedPreviewSizes(),
+      base::Bind(&ImageCaptureResource::OnPluginMsgGetPreviewSizesReply,
+                 base::Unretained(this)));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t ImageCaptureResource::CaptureStillImage(
+    PPB_ImageCapture_Private_ShutterCallback shutter_callback,
+    PPB_ImageCapture_Private_PreviewCallback preview_callback,
+    PPB_ImageCapture_Private_JpegCallback jpeg_callback,
+    int64_t* sequence_id) {
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+void ImageCaptureResource::OnPluginMsgOpenReply(
+    const ResourceMessageReplyParams& params) {
+  if (open_state_ == BEFORE_OPEN && params.result() == PP_OK)
+    open_state_ = OPENED;
+
+  // The callback may have been aborted by Close().
+  if (TrackedCallback::IsPending(open_callback_))
+    open_callback_->Run(params.result());
+}
+
+void ImageCaptureResource::OnPluginMsgGetPreviewSizesReply(
+    const ResourceMessageReplyParams& params,
+    const std::vector<PP_Size>& preview_sizes) {
+  if (!TrackedCallback::IsPending(get_capabilities_callback_))
+    return;
+
+  // Return camera capabilities.
+  int32_t result = params.result();
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(get_capabilities_callback_);
+  if (result == PP_OK) {
+    camera_capabilities_ = new CameraCapabilitiesResource(
+        pp_instance(), preview_sizes);
+    *get_capabilities_output_ = camera_capabilities_->GetReference();
+  }
+  get_capabilities_output_ = NULL;
+  callback->Run(result == PP_OK ? PP_OK : PP_ERROR_FAILED);
+}
+
+}  // namespace proxy
+}  // namespace ppapi