Support multiple HW video decoders per context.

ppapi/examples/gles2/gles2.cc

 // Copyright (c) 2011 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 <string.h>
 
 #include <iostream>
 #include <sstream>
 #include <list>
 #include <map>
@@ skipping 55 matching lines @@
                                      PP_Size dimensions);
   virtual void DismissPictureBuffer(PP_Resource decoder,
                                     int32_t picture_buffer_id);
   virtual void PictureReady(PP_Resource decoder, const PP_Picture_Dev& picture);
   virtual void EndOfStream(PP_Resource decoder);
   virtual void NotifyError(PP_Resource decoder, PP_VideoDecodeError_Dev error);
 
  private:
   enum { kNumConcurrentDecodes = 7 };
 
-  // Initialize Video Decoder.
-  void InitializeDecoder();
+  // State of a single decoder.
+  struct DecoderState {
+    DecoderState(GLES2DemoInstance* gles2, pp::VideoDecoder_Dev* decoder);
+    ~DecoderState();
 
-  // Callbacks passed into pp:VideoDecoder_Dev functions.
-  void DecoderInitDone(int32_t result);
-  void DecoderBitstreamDone(int32_t result, int bitstream_buffer_id);
-  void DecoderFlushDone(int32_t result);
+    // Cleanup helpers.
+    void DeleteOutstandingBitstreamBuffers();
+    void DeleteOutstandingTextures();
 
-  // Decode helpers.
-  void DecodeNextNALUs();
-  void DecodeNextNALU();
-  void GetNextNALUBoundary(size_t start_pos, size_t* end_pos);
-  void PaintStart(const PP_Picture_Dev& picture);
-  void DeleteOutstandingBitstreamBuffers();
+    // Decode helpers.
+    void DecodeNextNALUs();
+    void DecodeNextNALU();
+    static void GetNextNALUBoundary(size_t start_pos, size_t* end_pos);
+    void DecoderBitstreamDone(int32_t result, int bitstream_buffer_id);
+    void DecoderFlushDone(int32_t result);
+
+    GLES2DemoInstance* gles2_;
+    pp::VideoDecoder_Dev* decoder_;
+    pp::CompletionCallbackFactory<DecoderState> callback_factory_;
+    int next_picture_buffer_id_;
+    int next_bitstream_buffer_id_;
+    size_t encoded_data_next_pos_to_decode_;
+    std::set<int> bitstream_ids_at_decoder_;
+    // Map of texture buffers indexed by buffer id.
+    typedef std::map<int, PP_PictureBuffer_Dev> PictureBufferMap;
+    PictureBufferMap buffers_by_id_;
+    // Map of bitstream buffers indexed by id.
+    typedef std::map<int, pp::Buffer_Dev*> BitstreamBufferMap;
+    BitstreamBufferMap bitstream_buffers_by_id_;
+  };
+
+  // Initialize Video Decoders.
+  void InitializeDecoders();
 
   // GL-related functions.
   void InitGL();
   GLuint CreateTexture(int32_t width, int32_t height);
   void CreateGLObjects();
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void DeleteTexture(GLuint id);
-  void DeleteOutstandingTextures();
-  void PaintFinished(int32_t result, int picture_buffer_id);
+  void PaintFinished(int32_t result, PP_Resource decoder,
+                     int picture_buffer_id);
 
   // Log an error to the developer console and stderr (though the latter may be
   // closed due to sandboxing or blackholed for other reasons) by creating a
   // temporary of this type and streaming to it.  Example usage:
   // LogError(this).s() << "Hello world: " << 42;
   class LogError {
    public:
     LogError(GLES2DemoInstance* demo) : demo_(demo) {}
     ~LogError() {
       const std::string& msg = stream_.str();
       demo_->console_if_->Log(demo_->pp_instance(), PP_LOGLEVEL_ERROR,
                               pp::Var(msg).pp_var());
       std::cerr << msg << std::endl;
     }
     // Impl note: it would have been nicer to have LogError derive from
     // std::ostringstream so that it can be streamed to directly, but lookup
     // rules turn streamed string literals to hex pointers on output.
     std::ostringstream& s() { return stream_; }
    private:
     GLES2DemoInstance* demo_;  // Unowned.
     std::ostringstream stream_;
   };
 
   pp::Size position_size_;

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

nit: rename position_size_ to viewport_size_? (If that's accurate)

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

It's not.
The size is that of the position argument to DidChangeView(), so in that sense
is a "view".  But in another (more relevant :)) sense, viewport is a quarter of
this. 

Renamed to plugin_size_.

-  int next_picture_buffer_id_;
-  int next_bitstream_buffer_id_;
   bool is_painting_;
-  pp::CompletionCallbackFactory<GLES2DemoInstance> callback_factory_;
-  size_t encoded_data_next_pos_to_decode_;
-  std::set<int> bitstream_ids_at_decoder_;
   // When decode outpaces render, we queue up decoded pictures for later
-  // painting.
-  std::list<PP_Picture_Dev> pictures_pending_paint_;
+  // painting.  Elements are <decoder,picture>.
+  std::list<std::pair<PP_Resource, PP_Picture_Dev> > pictures_pending_paint_;
   int num_frames_rendered_;
-
-  // Map of texture buffers indexed by buffer id.
-  typedef std::map<int, PP_PictureBuffer_Dev> PictureBufferMap;
-  PictureBufferMap buffers_by_id_;
-  // Map of bitstream buffers indexed by id.
-  typedef std::map<int, pp::Buffer_Dev*> BitstreamBufferMap;
-  BitstreamBufferMap bitstream_buffers_by_id_;
   PP_TimeTicks first_frame_delivered_ticks_;
   PP_TimeTicks last_swap_request_ticks_;
   PP_TimeTicks swap_ticks_;
+  pp::CompletionCallbackFactory<GLES2DemoInstance> callback_factory_;
 
   // Unowned pointers.
   const struct PPB_Console_Dev* console_if_;
   const struct PPB_Core* core_if_;
   const struct PPB_OpenGLES2_Dev* gles2_if_;
 
   // Owned data.
   pp::Context3D_Dev* context_;
   pp::Surface3D_Dev* surface_;
-  pp::VideoDecoder_Dev* video_decoder_;
+  typedef std::map<int, DecoderState*> Decoders;
+  Decoders video_decoders_;
 };
 
+GLES2DemoInstance::DecoderState::DecoderState(GLES2DemoInstance* gles2,
+                                              pp::VideoDecoder_Dev* decoder)
+    : gles2_(gles2), decoder_(decoder), callback_factory_(this),
+      next_picture_buffer_id_(0),
+      next_bitstream_buffer_id_(0), encoded_data_next_pos_to_decode_(0) {
+};
+
+GLES2DemoInstance::DecoderState::~DecoderState() {
+  delete decoder_;
+  decoder_ = NULL;
+}
+
+void GLES2DemoInstance::DecoderState::DeleteOutstandingTextures() {
+  for (PictureBufferMap::iterator it = buffers_by_id_.begin();
+       it != buffers_by_id_.end(); ++it) {
+    gles2_->DeleteTexture(it->second.texture_id);
+  }
+  buffers_by_id_.clear();
+}
+
+void GLES2DemoInstance::DecoderState::DeleteOutstandingBitstreamBuffers() {
+  for (BitstreamBufferMap::iterator it = bitstream_buffers_by_id_.begin();
+       it != bitstream_buffers_by_id_.end(); ++it) {
+    delete it->second;
+  }
+  bitstream_buffers_by_id_.clear();
+}
+
 GLES2DemoInstance::GLES2DemoInstance(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance), pp::Graphics3DClient_Dev(this),
       pp::VideoDecoderClient_Dev(this),
-      next_picture_buffer_id_(0),
-      next_bitstream_buffer_id_(0),
-      callback_factory_(this),
-      encoded_data_next_pos_to_decode_(0),
       num_frames_rendered_(0),
       first_frame_delivered_ticks_(-1),
       swap_ticks_(0),
+      callback_factory_(this),
       context_(NULL),
-      surface_(NULL),
-      video_decoder_(NULL) {
+      surface_(NULL) {
   assert((console_if_ = static_cast<const struct PPB_Console_Dev*>(
       module->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE))));
   assert((core_if_ = static_cast<const struct PPB_Core*>(
       module->GetBrowserInterface(PPB_CORE_INTERFACE))));
   assert((gles2_if_ = static_cast<const struct PPB_OpenGLES2_Dev*>(
       module->GetBrowserInterface(PPB_OPENGLES2_DEV_INTERFACE))));
 }
 
 GLES2DemoInstance::~GLES2DemoInstance() {
-  delete video_decoder_;  // May be NULL, which is fine.
-  DeleteOutstandingBitstreamBuffers();
-  DeleteOutstandingTextures();
+  for (Decoders::iterator it = video_decoders_.begin();
+       it != video_decoders_.end(); ++it) {
+    it->second->DeleteOutstandingBitstreamBuffers();

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

Any reason not to push these DeleteOutstandingBitstreamBuffers() and
DeleteOutstandingTextures() into the DecoderState destructor?

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done (and in-lined).

+    it->second->DeleteOutstandingTextures();
+    delete it->second;
+  }
+  video_decoders_.clear();
   delete surface_;
   delete context_;
 }
 
-void GLES2DemoInstance::DeleteOutstandingTextures() {
-  for (PictureBufferMap::iterator it = buffers_by_id_.begin();
-       it != buffers_by_id_.end(); ++it) {
-    DeleteTexture(it->second.texture_id);
-  }
-  buffers_by_id_.clear();
-}
-
-void GLES2DemoInstance::DeleteOutstandingBitstreamBuffers() {
-  for (BitstreamBufferMap::iterator it = bitstream_buffers_by_id_.begin();
-       it != bitstream_buffers_by_id_.end(); ++it) {
-    delete it->second;
-  }
-  bitstream_buffers_by_id_.clear();
-}
-
 void GLES2DemoInstance::DidChangeView(
     const pp::Rect& position, const pp::Rect& clip_ignored) {
   if (position.width() == 0 || position.height() == 0)
     return;
   if (position_size_.width()) {
     assert(position.size() == position_size_);
     return;
   }
   position_size_ = position.size();
 
   // Initialize graphics.
   InitGL();
-  InitializeDecoder();
+  InitializeDecoders();
 }
 
-void GLES2DemoInstance::InitializeDecoder() {
+void GLES2DemoInstance::InitializeDecoders() {
   PP_VideoConfigElement configs = PP_VIDEOATTR_DICTIONARY_TERMINATOR;
 
-  assert(!video_decoder_);
-  video_decoder_ = new pp::VideoDecoder_Dev(*this, *context_, &configs);
-  assert(!video_decoder_->is_null());
-
-  DecodeNextNALUs();
+  assert(video_decoders_.empty());
+  for (int i = 0; i < 2; ++i) {

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

Instead of 2, make into an enum constant? (like kNumConcurrentDecodes)

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.
(I previously hadn't b/c the /2 was still hard-coded into the rendering code,
but I was being silly; is fine to use the constant there too)

+    DecoderState* state = new DecoderState(
+        this, new pp::VideoDecoder_Dev(*this, *context_, &configs));
+    assert(!state->decoder_->is_null());

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

If you're going the DecoderClient route, could probably have an accessor for
state->decoder_

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.

+    assert(video_decoders_.insert(std::make_pair(
+        state->decoder_->pp_resource(), state)).second);
+    state->DecodeNextNALUs();
+  }
 }
 
-void GLES2DemoInstance::DecoderBitstreamDone(
+void GLES2DemoInstance::DecoderState::DecoderBitstreamDone(
     int32_t result, int bitstream_buffer_id) {
   assert(bitstream_ids_at_decoder_.erase(bitstream_buffer_id) == 1);
   BitstreamBufferMap::iterator it =
       bitstream_buffers_by_id_.find(bitstream_buffer_id);
   assert(it != bitstream_buffers_by_id_.end());
   delete it->second;
   bitstream_buffers_by_id_.erase(it);
   DecodeNextNALUs();
 }
 
-void GLES2DemoInstance::DecoderFlushDone(int32_t result) {
+void GLES2DemoInstance::DecoderState::DecoderFlushDone(int32_t result) {
+  assert(result == PP_OK);
   // Check that each bitstream buffer ID we handed to the decoder got handed
   // back to us.
   assert(bitstream_ids_at_decoder_.empty());
-  delete video_decoder_;
-  video_decoder_ = NULL;
+  delete decoder_;
+  decoder_ = NULL;
 }
 
 static bool LookingAtNAL(const unsigned char* encoded, size_t pos) {
   return pos + 3 < kDataLen &&
       encoded[pos] == 0 && encoded[pos + 1] == 0 &&
       encoded[pos + 2] == 0 && encoded[pos + 3] == 1;
 }
 
-void GLES2DemoInstance::GetNextNALUBoundary(
+void GLES2DemoInstance::DecoderState::GetNextNALUBoundary(
     size_t start_pos, size_t* end_pos) {
   assert(LookingAtNAL(kData, start_pos));
   *end_pos = start_pos;
   *end_pos += 4;
   while (*end_pos + 3 < kDataLen &&
          !LookingAtNAL(kData, *end_pos)) {
     ++*end_pos;
   }
   if (*end_pos + 3 >= kDataLen) {
     *end_pos = kDataLen;
     return;
   }
 }
 
-void GLES2DemoInstance::DecodeNextNALUs() {
+void GLES2DemoInstance::DecoderState::DecodeNextNALUs() {
   while (encoded_data_next_pos_to_decode_ <= kDataLen &&
          bitstream_ids_at_decoder_.size() < kNumConcurrentDecodes) {
     DecodeNextNALU();
   }
 }
 
-void GLES2DemoInstance::DecodeNextNALU() {
+void GLES2DemoInstance::DecoderState::DecodeNextNALU() {
   if (encoded_data_next_pos_to_decode_ == kDataLen) {
     ++encoded_data_next_pos_to_decode_;
-    pp::CompletionCallback cb =
-        callback_factory_.NewCallback(&GLES2DemoInstance::DecoderFlushDone);
-    video_decoder_->Flush(cb);
+    pp::CompletionCallback cb = callback_factory_.NewCallback(
+        &GLES2DemoInstance::DecoderState::DecoderFlushDone);
+    decoder_->Flush(cb);
     return;
   }
   size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
   GetNextNALUBoundary(start_pos, &end_pos);
-  pp::Buffer_Dev* buffer = new pp::Buffer_Dev(this, end_pos - start_pos);
+  pp::Buffer_Dev* buffer = new pp::Buffer_Dev(gles2_, end_pos - start_pos);
   PP_VideoBitstreamBuffer_Dev bitstream_buffer;
   int id = ++next_bitstream_buffer_id_;
   bitstream_buffer.id = id;
   bitstream_buffer.size = end_pos - start_pos;
   bitstream_buffer.data = buffer->pp_resource();
   memcpy(buffer->data(), kData + start_pos, end_pos - start_pos);
   assert(bitstream_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
 
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
-          &GLES2DemoInstance::DecoderBitstreamDone, id);
+          &GLES2DemoInstance::DecoderState::DecoderBitstreamDone, id);
   assert(bitstream_ids_at_decoder_.insert(id).second);
-  video_decoder_->Decode(bitstream_buffer, cb);
   encoded_data_next_pos_to_decode_ = end_pos;
+  decoder_->Decode(bitstream_buffer, cb);
 }
 
 void GLES2DemoInstance::ProvidePictureBuffers(
     PP_Resource decoder, uint32_t req_num_of_bufs, PP_Size dimensions) {
-  assert(decoder == video_decoder_->pp_resource());
   std::vector<PP_PictureBuffer_Dev> buffers;
-  for (uint32_t i = 0; i < req_num_of_bufs; i++) {
+  DecoderState* state = video_decoders_[decoder];
+  assert(state);
+  for (uint32_t i = 0; i < req_num_of_bufs; ++i) {

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

Put this behavior in DecoderState object if not too annoying.

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.

     PP_PictureBuffer_Dev buffer;
     buffer.texture_id = CreateTexture(dimensions.width, dimensions.height);
-    int id = ++next_picture_buffer_id_;
+    int id = ++state->next_picture_buffer_id_;
     buffer.id = id;
     buffers.push_back(buffer);
-    assert(buffers_by_id_.insert(std::make_pair(id, buffer)).second);
+    assert(state->buffers_by_id_.insert(std::make_pair(id, buffer)).second);
   }
-  video_decoder_->AssignPictureBuffers(buffers);
+  state->decoder_->AssignPictureBuffers(buffers);
 }
 
 void GLES2DemoInstance::DismissPictureBuffer(PP_Resource decoder,
                                              int32_t picture_buffer_id) {
-  assert(decoder == video_decoder_->pp_resource());
-  PictureBufferMap::iterator it = buffers_by_id_.find(picture_buffer_id);
-  assert(it != buffers_by_id_.end());
+  DecoderState* state = video_decoders_[decoder];
+  assert(state);
+  DecoderState::PictureBufferMap::iterator it =

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

Put this behavior in DecoderState object if not too annoying.

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.

+      state->buffers_by_id_.find(picture_buffer_id);
+  assert(it != state->buffers_by_id_.end());
   DeleteTexture(it->second.texture_id);
-  buffers_by_id_.erase(it);
+  state->buffers_by_id_.erase(it);
 }
 
 void GLES2DemoInstance::PictureReady(PP_Resource decoder,
                                      const PP_Picture_Dev& picture) {
-  assert(decoder == video_decoder_->pp_resource());
-  PaintStart(picture);
-}
-
-void GLES2DemoInstance::PaintStart(const PP_Picture_Dev& picture) {
   if (first_frame_delivered_ticks_ == -1)
     assert((first_frame_delivered_ticks_ = core_if_->GetTimeTicks()) != -1);
   if (is_painting_) {
-    pictures_pending_paint_.push_back(picture);
+    pictures_pending_paint_.push_back(std::make_pair(decoder, picture));
     return;
   }
-  PictureBufferMap::iterator it =
-      buffers_by_id_.find(picture.picture_buffer_id);
-  assert(it != buffers_by_id_.end());
+  DecoderState* state = video_decoders_[decoder];
+  assert(state);
+  DecoderState::PictureBufferMap::iterator it =

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

If you're going the DecoderClient route, smush this into a
GetPictureBufferByID() method.

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.

+      state->buffers_by_id_.find(picture.picture_buffer_id);
+  assert(it != state->buffers_by_id_.end());
   const PP_PictureBuffer_Dev& buffer = it->second;
   assert(!is_painting_);
   is_painting_ = true;
+  int x = 0;
+  int y = 0;
+  if (state != video_decoders_.begin()->second) {
+    x = position_size_.width() / 2;
+    y = position_size_.height() / 2;
+  }
+  gles2_if_->Viewport(context_->pp_resource(), x, y,
+                      position_size_.width() / 2, position_size_.height() / 2);
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
       context_->pp_resource(), GL_TEXTURE_2D, buffer.texture_id);
   gles2_if_->DrawArrays(context_->pp_resource(), GL_TRIANGLE_STRIP, 0, 4);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
-          &GLES2DemoInstance::PaintFinished, buffer.id);
+          &GLES2DemoInstance::PaintFinished, decoder, buffer.id);
   last_swap_request_ticks_ = core_if_->GetTimeTicks();
   assert(surface_->SwapBuffers(cb) == PP_OK_COMPLETIONPENDING);
 }
 
 void GLES2DemoInstance::EndOfStream(PP_Resource decoder) {
-  assert(decoder == video_decoder_->pp_resource());
 }
 
 void GLES2DemoInstance::NotifyError(PP_Resource decoder,
                                     PP_VideoDecodeError_Dev error) {
-  assert(decoder == video_decoder_->pp_resource());
   LogError(this).s() << "Received error: " << error;
   assert(!"Unexpected error; see stderr for details");
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class GLES2DemoModule : public pp::Module {
  public:
   GLES2DemoModule() : pp::Module() {}
   virtual ~GLES2DemoModule() {}
@@ skipping 14 matching lines @@
   int32_t surface_attributes[] = {
     PP_GRAPHICS3DATTRIB_WIDTH, position_size_.width(),
     PP_GRAPHICS3DATTRIB_HEIGHT, position_size_.height(),
     PP_GRAPHICS3DATTRIB_NONE
   };
   surface_ = new pp::Surface3D_Dev(*this, 0, surface_attributes);
   assert(!surface_->is_null());
 
   assert(!context_->BindSurfaces(*surface_, *surface_));
 
-  // Set viewport window size and clear color bit.
+  // Clear color bit.
   gles2_if_->Clear(context_->pp_resource(), GL_COLOR_BUFFER_BIT);
-  gles2_if_->Viewport(context_->pp_resource(), 0, 0,
-                      position_size_.width(), position_size_.height());
 
   assert(BindGraphics(*surface_));
   assertNoGLError();
 
   CreateGLObjects();
 }
 
-void GLES2DemoInstance::PaintFinished(int32_t result, int picture_buffer_id) {
+void GLES2DemoInstance::PaintFinished(int32_t result, PP_Resource decoder,
+                                      int picture_buffer_id) {
   swap_ticks_ += core_if_->GetTimeTicks() - last_swap_request_ticks_;
   is_painting_ = false;
   ++num_frames_rendered_;
   if (num_frames_rendered_ % 50 == 0) {
     double elapsed = core_if_->GetTimeTicks() - first_frame_delivered_ticks_;
     double fps = (elapsed > 0) ? num_frames_rendered_ / elapsed : 1000;
     double ms_per_swap = (swap_ticks_ * 1e3) / num_frames_rendered_;
     LogError(this).s() << "Rendered frames: " << num_frames_rendered_
                        << ", fps: " << fps << ", with average ms/swap of: "
                        << ms_per_swap;
   }
-  if (video_decoder_)
-    video_decoder_->ReusePictureBuffer(picture_buffer_id);
+  DecoderState* state = video_decoders_[decoder];
+  if (state && state->decoder_)

[vrk (LEFT CHROMIUM), 2011/08/16 22:06:21]

If you're going the DecoderClient route, here too you could just use an accesor
for state->decoder_

[Ami GONE FROM CHROMIUM, 2011/08/16 22:56:26]

Done.

+    state->decoder_->ReusePictureBuffer(picture_buffer_id);
   if (!pictures_pending_paint_.empty()) {
-    PP_Picture_Dev picture = pictures_pending_paint_.front();
+    std::pair<PP_Resource, PP_Picture_Dev> decoder_picture =
+        pictures_pending_paint_.front();
     pictures_pending_paint_.pop_front();
-    PaintStart(picture);
+    PictureReady(decoder_picture.first, decoder_picture.second);
   }
 }
 
 GLuint GLES2DemoInstance::CreateTexture(int32_t width, int32_t height) {
   GLuint texture_id;
   gles2_if_->GenTextures(context_->pp_resource(), 1, &texture_id);
   assertNoGLError();
   // Assign parameters.
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
@@ skipping 95 matching lines @@
   gles2_if_->DeleteShader(context_->pp_resource(), shader);
 }
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new GLES2DemoModule();
 }
 }  // namespace pp