ppapi/proxy/proxy_array_output.h

   1 // Copyright (c) 2012 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 #ifndef PPAPI_PROXY_PROXY_ARRAY_OUTPUT_H_
   6 #define PPAPI_PROXY_PROXY_ARRAY_OUTPUT_H_
   7
   8 #include <vector>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "ppapi/c/pp_array_output.h"
  13
  14 // Like ppapi/cpp/array_output.h file in the C++ wrappers but for use in the
  15 // proxy where we can't link to the C++ wrappers. This also adds a refcounted
  16 // version.
  17 //
  18 // Use ArrayOutputAdapter when calling a function that synchronously returns
  19 // an array of data. Use RefCountedArrayOutputAdapterWithStorage for
  20 // asynchronous returns:
  21 //
  22 // void OnCallbackComplete(
  23 //     int32_t result,
  24 //     scoped_refptr<RefCountedArrayOutputAdapter<PP_Resource> > output) {
  25 //   // Vector is in output->output().
  26 // }
  27 //
  28 // void ScheduleCallback() {
  29 //   base::scoped_refptr<RefCountedArrayOutputAdapter<PP_Resource> > output;
  30 //
  31 //   callback = factory.NewOptionalCallback(&OnCallbackComplete, output);
  32 //   DoSomethingAsynchronously(output->pp_array_output(),
  33 //                             callback.pp_completion_callback());
  34 //   ...
  35 namespace ppapi {
  36 namespace proxy {
  37
  38 // Non-templatized base class for the array output conversion. It provides the
  39 // C implementation of a PP_ArrayOutput whose callback function is implemented
  40 // as a virtual call on a derived class. Do not use directly, use one of the
  41 // derived classes below.
  42 class ArrayOutputAdapterBase {
  43  public:
  44   ArrayOutputAdapterBase() {
  45     pp_array_output_.GetDataBuffer =
  46         &ArrayOutputAdapterBase::GetDataBufferThunk;
  47     pp_array_output_.user_data = this;
  48   }
  49   virtual ~ArrayOutputAdapterBase() {}
  50
  51   const PP_ArrayOutput& pp_array_output() { return pp_array_output_; }
  52
  53  protected:
  54   virtual void* GetDataBuffer(uint32_t element_count,
  55                               uint32_t element_size) = 0;
  56
  57  private:
  58   static void* GetDataBufferThunk(void* user_data,
  59                                   uint32_t element_count,
  60                                   uint32_t element_size);
  61
  62   PP_ArrayOutput pp_array_output_;
  63
  64   // Disallow copying and assignment. This will do the wrong thing for most
  65   // subclasses.
  66   ArrayOutputAdapterBase(const ArrayOutputAdapterBase&);
  67   ArrayOutputAdapterBase& operator=(const ArrayOutputAdapterBase&);
  68 };
  69
  70 // This adapter provides functionality for implementing a PP_ArrayOutput
  71 // structure as writing to a given vector object.
  72 //
  73 // This is generally used internally in the C++ wrapper objects to
  74 // write into an output parameter supplied by the plugin. If the element size
  75 // that the browser is writing does not match the size of the type we're using
  76 // this will assert and return NULL (which will cause the browser to fail the
  77 // call).
  78 //
  79 // Example that allows the browser to write into a given vector:
  80 //   void DoFoo(std::vector<int>* results) {
  81 //     ArrayOutputAdapter<int> adapter(results);
  82 //     ppb_foo->DoFoo(adapter.pp_array_output());
  83 //   }
  84 template<typename T>
  85 class ArrayOutputAdapter : public ArrayOutputAdapterBase {
  86  public:
  87   ArrayOutputAdapter(std::vector<T>* output) : output_(output) {}
  88
  89  protected:
  90   // Two-step init for the "with storage" version below.
  91   ArrayOutputAdapter() : output_(NULL) {}
  92   void set_output(std::vector<T>* output) { output_ = output; }
  93
  94   // ArrayOutputAdapterBase implementation.
  95   virtual void* GetDataBuffer(uint32_t element_count, uint32_t element_size) {
  96     DCHECK(element_size == sizeof(T));
  97     if (element_count == 0 || element_size != sizeof(T))
  98       return NULL;
  99     output_->resize(element_count);
 100     return &(*output_)[0];
 101   }
 102
 103  private:
 104   std::vector<T>* output_;
 105 };
 106
 107 template<typename T>
 108 class ArrayOutputAdapterWithStorage : public ArrayOutputAdapter<T> {
 109  public:
 110   ArrayOutputAdapterWithStorage() {
 111     // Note: "this->" is required due to two-phase name lookup where it isn't
 112     // allowed to look in the base class during parsing.
 113     this->set_output(&output_storage_);
 114   }
 115
 116   std::vector<T>& output() { return output_storage_; }
 117
 118  private:
 119   std::vector<T> output_storage_;
 120 };
 121
 122 // A reference counted version of ArrayOutputAdapterWithStorage. Since it
 123 // doesn't make much sense to heap-allocate one without storage, we don't
 124 // call it "with storage" to keep the name length under control.
 125 template<typename T>
 126 class RefCountedArrayOutputAdapter
 127     : public ArrayOutputAdapterWithStorage<T>,
 128       public base::RefCounted<RefCountedArrayOutputAdapter<T> > {
 129  public:
 130   RefCountedArrayOutputAdapter()
 131       : ArrayOutputAdapterWithStorage<T>() {
 132   }
 133 };
 134
 135 }  // namespace proxy
 136 }  // namespace ppapi
 137
 138 #endif  // PPAPI_PROXY_PROXY_ARRAY_OUTPUT_H_