From 679147eead574d186ebf3069647b4c23e8ccace6 Mon Sep 17 00:00:00 2001 From: Zeno Albisser Date: Thu, 15 Aug 2013 21:46:11 +0200 Subject: Initial import. --- chromium/ppapi/cpp/array_output.h | 272 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 272 insertions(+) create mode 100644 chromium/ppapi/cpp/array_output.h (limited to 'chromium/ppapi/cpp/array_output.h') diff --git a/chromium/ppapi/cpp/array_output.h b/chromium/ppapi/cpp/array_output.h new file mode 100644 index 00000000000..fe0bbc335bc --- /dev/null +++ b/chromium/ppapi/cpp/array_output.h @@ -0,0 +1,272 @@ +// Copyright (c) 2012 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. + +#ifndef PPAPI_CPP_ARRAY_OUTPUT_H_ +#define PPAPI_CPP_ARRAY_OUTPUT_H_ + +#include + +#include "ppapi/c/pp_array_output.h" +#include "ppapi/c/pp_resource.h" +#include "ppapi/cpp/logging.h" +#include "ppapi/cpp/pass_ref.h" +#include "ppapi/cpp/var.h" + +namespace pp { + +// Converts the given array of PP_Resources into an array of the requested +// C++ resource types, passing ownership of a reference in the process. +// +// This is used to convert output arrays of resources that the browser has +// generated into the more convenient C++ wrappers for those resources. The +// initial "PassRef" parameter is there to emphasize what happens to the +// reference count of the input resource and to match the resource constructors +// that look the same. +template +inline void ConvertPPResourceArrayToObjects( + PassRef, + const std::vector& input, + std::vector* output) { + output->resize(0); + output->reserve(input.size()); + for (size_t i = 0; i < input.size(); i++) + output->push_back(ResourceObjectType(PASS_REF, input[i])); +} + +// Non-templatized base class for the array output conversion. It provides the +// C implementation of a PP_ArrayOutput whose callback function is implemented +// as a virtual call on a derived class. Do not use directly, use one of the +// derived classes below. +class ArrayOutputAdapterBase { + public: + ArrayOutputAdapterBase() { + pp_array_output_.GetDataBuffer = + &ArrayOutputAdapterBase::GetDataBufferThunk; + pp_array_output_.user_data = this; + } + virtual ~ArrayOutputAdapterBase() {} + + const PP_ArrayOutput& pp_array_output() { return pp_array_output_; } + + protected: + virtual void* GetDataBuffer(uint32_t element_count, + uint32_t element_size) = 0; + + private: + static void* GetDataBufferThunk(void* user_data, + uint32_t element_count, + uint32_t element_size); + + PP_ArrayOutput pp_array_output_; + + // Disallow copying and assignment. This will do the wrong thing for most + // subclasses. + ArrayOutputAdapterBase(const ArrayOutputAdapterBase&); + ArrayOutputAdapterBase& operator=(const ArrayOutputAdapterBase&); +}; + +// This adapter provides functionality for implementing a PP_ArrayOutput +// structure as writing to a given vector object. +// +// This is generally used internally in the C++ wrapper objects to +// write into an output parameter supplied by the plugin. If the element size +// that the browser is writing does not match the size of the type we're using +// this will assert and return NULL (which will cause the browser to fail the +// call). +// +// Example that allows the browser to write into a given vector: +// void DoFoo(std::vector* results) { +// ArrayOutputAdapter adapter(results); +// ppb_foo->DoFoo(adapter.pp_array_output()); +// } +template +class ArrayOutputAdapter : public ArrayOutputAdapterBase { + public: + ArrayOutputAdapter(std::vector* output) : output_(output) {} + + protected: + // Two-step init for the "with storage" version below. + ArrayOutputAdapter() : output_(NULL) {} + void set_output(std::vector* output) { output_ = output; } + + // ArrayOutputAdapterBase implementation. + virtual void* GetDataBuffer(uint32_t element_count, uint32_t element_size) { + if (element_count == 0) + return NULL; + PP_DCHECK(element_size == sizeof(T)); + if (element_size != sizeof(T)) + return NULL; + output_->resize(element_count); + return &(*output_)[0]; + } + + private: + std::vector* output_; +}; + +// This adapter provides functionality for implementing a PP_ArrayOutput +// structure as writing resources to a given vector object. +// +// When returning an array of resources, the browser will write PP_Resources +// via a PP_ArrayOutput. This code will automatically convert the PP_Resources +// to the given wrapper type, (as long as that wrapper type supports the +// correct constructor). The ownership of the resources that the browser passed +// to us will be transferred to the C++ wrapper object. +// +// Conversion of the PP_Resources to the C++ wrapper object occurs in the +// destructor. This object is intended to be used on the stack in a C++ wrapper +// object for a call. +// +// Example: +// void GetFiles(std::vector* results) { +// ResourceArrayOutputAdapter adapter(results); +// ppb_foo->DoFoo(adapter.pp_array_output()); +// } +template +class ResourceArrayOutputAdapter : public ArrayOutputAdapterBase { + public: + explicit ResourceArrayOutputAdapter(std::vector* output) + : output_(output) { + output_->resize(0); + } + virtual ~ResourceArrayOutputAdapter() { + ConvertPPResourceArrayToObjects(PASS_REF, intermediate_output_, output_); + } + + protected: + // Two-step init for the "with storage" version below. + ResourceArrayOutputAdapter() : output_(NULL) {} + void set_output(T* output) { output_ = output; } + + // ArrayOutputAdapterBase implementation. + virtual void* GetDataBuffer(uint32_t element_count, + uint32_t element_size) { + if (element_count == 0) + return NULL; + PP_DCHECK(element_size == sizeof(PP_Resource)); + if (element_size != sizeof(PP_Resource)) + return NULL; + intermediate_output_.resize(element_count); + return &intermediate_output_[0]; + } + + private: + std::vector intermediate_output_; + std::vector* output_; +}; + +// This adapter is like the ArrayOutputAdapter except that it also contains +// the underlying std::vector that will be populated (rather than writing it to +// an object passed into the constructor). +// +// This is used by the CompletionCallbackFactory system to collect the output +// parameters from an async function call. The collected data is then passed to +// the plugins callback function. +// +// You can also use it directly if you want to have an array output and aren't +// using the CompletionCallbackFactory. For example, if you're calling a +// PPAPI function DoFoo that takes a PP_OutputArray that is supposed to be +// writing integers, do this: +// +// ArrayOutputAdapterWithStorage adapter; +// ppb_foo->DoFoo(adapter.pp_output_array()); +// const std::vector& result = adapter.output(); +template +class ArrayOutputAdapterWithStorage : public ArrayOutputAdapter { + public: + ArrayOutputAdapterWithStorage() { + this->set_output(&output_storage_); + } + + std::vector& output() { return output_storage_; } + + private: + std::vector output_storage_; +}; + +// This adapter is like the ArrayOutputAdapterWithStorage except this +// additionally converts PP_Var structs to pp::Var objects. +// +// You can also use it directly if you want to have an array output and aren't +// using the CompletionCallbackFactory. For example, if you're calling a +// PPAPI function GetVars that takes a PP_OutputArray that is supposed to be +// writing PP_Vars, do this: +// +// VarArrayOutputAdapterWithStorage adapter; +// ppb_foo->GetVars(adapter.pp_output_array()); +// const std::vector& result = adapter.output(). +// +// This one is non-inline since it's not templatized. +class VarArrayOutputAdapterWithStorage : public ArrayOutputAdapter { + public: + VarArrayOutputAdapterWithStorage(); + virtual ~VarArrayOutputAdapterWithStorage(); + + // Returns the final array of resource objects, converting the PP_Vars + // written by the browser to pp::Var objects. + // + // This function should only be called once or we would end up converting + // the array more than once, which would mess up the refcounting. + std::vector& output(); + + private: + // The browser will write the PP_Vars into this array. + std::vector temp_storage_; + + // When asked for the output, the resources above will be converted to the + // C++ resource objects in this array for passing to the calling code. + std::vector output_storage_; +}; + +// This adapter is like the ArrayOutputAdapterWithStorage except this +// additionally converts PP_Resources to C++ wrapper objects of the given type. +// +// You can also use it directly if you want to have an array output and aren't +// using the CompletionCallbackFactory. For example, if you're calling a +// PPAPI function GetFiles that takes a PP_OutputArray that is supposed to be +// writing PP_Resources cooresponding to FileRefs, do this: +// +// ResourceArrayOutputAdapterWithStorage adapter; +// ppb_foo->GetFiles(adapter.pp_output_array()); +// std::vector result = adapter.output(). +template +class ResourceArrayOutputAdapterWithStorage + : public ArrayOutputAdapter { + public: + ResourceArrayOutputAdapterWithStorage() { + set_output(&temp_storage_); + } + + virtual ~ResourceArrayOutputAdapterWithStorage() { + if (!temp_storage_.empty()) { + // An easy way to release the resource references held by this object. + output(); + } + } + + // Returns the final array of resource objects, converting the PP_Resources + // written by the browser to resource objects. + // + // This function should only be called once or we would end up converting + // the array more than once, which would mess up the refcounting. + std::vector& output() { + PP_DCHECK(output_storage_.empty()); + + ConvertPPResourceArrayToObjects(PASS_REF, temp_storage_, &output_storage_); + temp_storage_.clear(); + return output_storage_; + } + + private: + // The browser will write the PP_Resources into this array. + std::vector temp_storage_; + + // When asked for the output, the resources above will be converted to the + // C++ resource objects in this array for passing to the calling code. + std::vector output_storage_; +}; + +} // namespace pp + +#endif // PPAPI_CPP_ARRAY_OUTPUT_H_ -- cgit v1.2.1