Implementation for Pepper C++ Video Decoder API (wrapper on top of C API).

ppapi/cpp/dev/video_decoder_dev.h

Index: ppapi/cpp/dev/video_decoder_dev.h
diff --git a/ppapi/cpp/dev/video_decoder_dev.h b/ppapi/cpp/dev/video_decoder_dev.h
index ba29abadcd285efebd69e65036d96fc169a21696..2ed3fd8a98e174c7538a8ff32d35533bd7a95cdb 100644
--- a/ppapi/cpp/dev/video_decoder_dev.h
+++ b/ppapi/cpp/dev/video_decoder_dev.h
@@ -57,23 +57,22 @@ class VideoDecoder : public Resource {
   //  |callback| will be called when decoder is initialized.
   //  |client| is the pointer to the client object. Ownership of the object is
   //  not transferred and it must outlive the lifetime of this class.
-  VideoDecoder(const Instance* instance, const std::vector<uint32_t>& config,
+  VideoDecoder(const Instance* instance,
+               const std::vector<PP_VideoConfigElement>& config,

[brettw, 2011/06/01 07:57:03]

I still have concerns about using a vector here, are you sure this is an
improvement over a C string?

As I mentioned in the previous review, the user must add the terminator in the
list even though the vector has a specific size and you're not used to having to
have some "ending marker" on a vector. This seems surprising and will crash.

How do we expect people to typically call it? For some things like this you have
a hardcoded list, and the vector makes this less convenient (since you'd just
make an array in C declaring the things you want, and pass it in). If we expect
this is the common usage, it seems like a regular C pointer like the C interface
is better.

If we expect callers to have to dynamically build it, the vector seems better,
but it seems like we should have some checks that it has the terminator at the
end. In this case, I'd make the constructor assert that it has the terminator,
and just return early (leaving the object uninitialized) if it's not there.

[Ville-Mikko Rautio, 2011/06/01 09:45:26]

Agreed. C-array style is better from user perspective. Changed it back.

                CompletionCallback callback, Client* client);
   ~VideoDecoder();
 
   // GetConfigs returns supported configurations that are subsets of given
   // |prototype_config|.
-  static std::vector<uint32_t> GetConfigs(
+  static std::vector<PP_VideoConfigElement> GetConfigs(
       Instance* instance,
-      const std::vector<uint32_t>& prototype_config);
+      const std::vector<PP_VideoConfigElement>& prototype_config);
 
   // Provides the decoder with picture buffers for video decoding.
   // AssignGLESBuffers provides texture-backed buffers, whereas
   // AssignSysmemBuffers provides system memory-backed buffers.
-  void AssignGLESBuffers(uint32_t no_of_buffers,
-                         const PP_GLESBuffer_Dev& buffers);
-  void AssignSysmemBuffers(uint32_t no_of_buffers,
-                           const PP_SysmemBuffer_Dev& buffers);
+  void AssignGLESBuffers(const std::vector<PP_GLESBuffer_Dev>& buffers);
+  void AssignSysmemBuffers(const std::vector<PP_SysmemBuffer_Dev>& buffers);
 
   // Decodes given bitstream buffer. Once decoder is done with processing
   // |bitstream_buffer| is will call |callback| with provided user data.