Fix crashes when loading gles2.cc on browser startup, and during playback.

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 "ppapi/c/dev/ppb_opengles_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/dev/context_3d_dev.h"
 #include "ppapi/cpp/dev/graphics_3d_client_dev.h"
@@ skipping 15 matching lines @@
 
 namespace {
 
 class GLES2DemoInstance : public pp::Instance, public pp::Graphics3DClient_Dev,
                           public pp::VideoDecoderClient_Dev {
  public:
   GLES2DemoInstance(PP_Instance instance, pp::Module* module);
   virtual ~GLES2DemoInstance();
 
   // pp::Instance implementation (see PPP_Instance).
-  virtual void DidChangeView(const pp::Rect& position_ignored,
-                             const pp::Rect& clip);
+  virtual void DidChangeView(const pp::Rect& position,
+                             const pp::Rect& clip_ignored);
 
   // pp::Graphics3DClient_Dev implementation.
   virtual void Graphics3DContextLost() {
-    // TODO(vrk/fischman): Properly reset after a lost graphics context.
+    // TODO(vrk/fischman): Properly reset after a lost graphics context.  In
+    // particular need to delete context_ & surface_ and re-create textures.
+    // Probably have to recreate the decoder from scratch, because old textures
+    // can still be outstanding in the decoder!
     assert(!"Unexpectedly lost graphics context");
   }
 
   // pp::VideoDecoderClient_Dev implementation.
   virtual void ProvidePictureBuffers(
       pp::VideoDecoder_Dev decoder, uint32_t req_num_of_bufs,
       PP_Size dimensions, PP_PictureBufferType_Dev type);
   virtual void DismissPictureBuffer(
       pp::VideoDecoder_Dev decoder, int32_t picture_buffer_id);
   virtual void PictureReady(
       pp::VideoDecoder_Dev decoder, const PP_Picture_Dev& picture);
   virtual void EndOfStream(pp::VideoDecoder_Dev decoder);
   virtual void NotifyError(
       pp::VideoDecoder_Dev decoder, PP_VideoDecodeError_Dev error);
 
  private:
   // Helper struct that stores data used by the shader program.
   struct ShaderInfo {
     GLint pos_location;
     GLint tc_location;
     GLint tex_location;
     GLuint vertex_buffers[2];
   };
 
+  // Serialize PPB_Video_Decoder_Dev operations w.r.t. GPU command buffer.
+  // TODO(fischman): figure out how much of this is actually necessary.
+  // Probably any necessary serialization ought to be happening in the
+  // PPAPI implementation, not in the plugin!
+  void FinishGL() {
+    gles2_if_->Finish(context_->pp_resource());

[scherkus (not reviewing), 2011/06/21 01:17:18]

wow yeah that's a lot of manual FinishGL-ing :\

+  }
+
   // Initialize Video Decoder.
   void InitializeDecoder();
 
   // 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);
   void DecoderAbortDone(int32_t result);
 
   // Decode helpers.
   void DecodeNextNALU();
   void GetNextNALUBoundary(size_t start_pos, size_t* end_pos);
   void Render(const PP_GLESBuffer_Dev& buffer);
 
   // GL-related functions.
-  void InitGL(int width, int height);
+  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 PaintFinished(int32_t result, int picture_buffer_id);
 
   // Assert |context_| isn't holding any GL Errors.
   void assertNoGLError() {
     assert(!gles2_if_->GetError(context_->pp_resource()));
   }
 
+  pp::Size position_size_;
   ShaderInfo program_data_;
   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_;
 
   // Map of texture buffers indexed by buffer id.
   typedef std::map<int, PP_GLESBuffer_Dev> PictureBufferMap;
   PictureBufferMap buffers_by_id_;
@@ skipping 25 matching lines @@
   assert(gles2_if_);
 }
 
 GLES2DemoInstance::~GLES2DemoInstance() {
   delete video_decoder_;
   delete surface_;
   delete context_;
 }
 
 void GLES2DemoInstance::DidChangeView(
-    const pp::Rect& position_ignored, const pp::Rect& clip) {
-  if (clip.width() == 0 || clip.height() == 0)
+    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(clip.width(), clip.height());
+  InitGL();
   InitializeDecoder();
 }
 
 void GLES2DemoInstance::InitializeDecoder() {
   if (video_decoder_)
     return;
   video_decoder_ = new pp::VideoDecoder_Dev(*this);
 
   PP_VideoConfigElement configs = PP_VIDEOATTR_DICTIONARY_TERMINATOR;
   pp::CompletionCallback cb =
@@ skipping 75 matching lines @@
   std::vector<PP_GLESBuffer_Dev> buffers;
   for (uint32_t i = 0; i < req_num_of_bufs; i++) {
     PP_GLESBuffer_Dev buffer;
     buffer.texture_id = CreateTexture(dimensions.width, dimensions.height);
     int id = ++next_picture_buffer_id_;
     buffer.info.id= id;
     buffers.push_back(buffer);
     bool result = buffers_by_id_.insert(std::make_pair(id, buffer)).second;
     assert(result);
   }
+  FinishGL();
   video_decoder_->AssignGLESBuffers(buffers);
 }
 
 void GLES2DemoInstance::DismissPictureBuffer(
     pp::VideoDecoder_Dev decoder, int32_t picture_buffer_id) {
   PictureBufferMap::iterator it = buffers_by_id_.find(picture_buffer_id);
   assert(it != buffers_by_id_.end());
   DeleteTexture(it->second.texture_id);
   buffers_by_id_.erase(it);
+
+  FinishGL();
 }
 
 void GLES2DemoInstance::PictureReady(
     pp::VideoDecoder_Dev decoder, const PP_Picture_Dev& picture) {
   PictureBufferMap::iterator it =
       buffers_by_id_.find(picture.picture_buffer_id);
   assert(it != buffers_by_id_.end());
   Render(it->second);
 }
 
 void GLES2DemoInstance::EndOfStream(pp::VideoDecoder_Dev decoder) {
 }
 
 void GLES2DemoInstance::NotifyError(
     pp::VideoDecoder_Dev decoder, PP_VideoDecodeError_Dev error) {
 }
 
 // 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() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new GLES2DemoInstance(instance, this);
   }
 };
 
-void GLES2DemoInstance::InitGL(int width, int height) {
-  assert(width && height);
+void GLES2DemoInstance::InitGL() {
+  assert(position_size_.width() && position_size_.height());
   is_painting_ = false;
 
-  if (context_)
-    delete(context_);
+  assert(!context_ && !surface_);
   context_ = new pp::Context3D_Dev(*this, 0, pp::Context3D_Dev(), NULL);
   assert(!context_->is_null());
 
   int32_t surface_attributes[] = {
-    PP_GRAPHICS3DATTRIB_WIDTH, width,
-    PP_GRAPHICS3DATTRIB_HEIGHT, height,
+    PP_GRAPHICS3DATTRIB_WIDTH, position_size_.width(),
+    PP_GRAPHICS3DATTRIB_HEIGHT, position_size_.height(),
     PP_GRAPHICS3DATTRIB_NONE
   };
-  if (surface_)
-    delete(surface_);
   surface_ = new pp::Surface3D_Dev(*this, 0, surface_attributes);
   assert(!surface_->is_null());
 
   int32_t bind_error = context_->BindSurfaces(*surface_, *surface_);
   assert(!bind_error);
 
   // Set viewport window size and clear color bit.
   gles2_if_->Clear(context_->pp_resource(), GL_COLOR_BUFFER_BIT);
-  gles2_if_->Viewport(context_->pp_resource(), 0, 0, width, height);
+  gles2_if_->Viewport(context_->pp_resource(), 0, 0,
+                      position_size_.width(), position_size_.height());
 
   bool success = BindGraphics(*surface_);
   assert(success);
   assertNoGLError();
 
   CreateGLObjects();
+
+  FinishGL();
 }
 
 void GLES2DemoInstance::Render(const PP_GLESBuffer_Dev& buffer) {
   if (is_painting_) {
     // We are dropping frames if we don't render fast enough -
     // that is why sometimes the last frame rendered is < 249.
-    if (video_decoder_)
+    if (video_decoder_) {
+      FinishGL();
       video_decoder_->ReusePictureBuffer(buffer.info.id);
+    }
     return;
   }
   is_painting_ = true;
   gles2_if_->ActiveTexture(context_->pp_resource(), GL_TEXTURE0);
   gles2_if_->BindTexture(
       context_->pp_resource(), GL_TEXTURE_2D, buffer.texture_id);
   gles2_if_->Uniform1i(context_->pp_resource(), program_data_.tex_location, 0);
   gles2_if_->DrawArrays(context_->pp_resource(), GL_TRIANGLE_STRIP, 0, 4);
   pp::CompletionCallback cb =
       callback_factory_.NewCallback(
           &GLES2DemoInstance::PaintFinished, buffer.info.id);
   int32_t error = surface_->SwapBuffers(cb);
   assert(error == PP_ERROR_WOULDBLOCK);
   assertNoGLError();
 }
 
 void GLES2DemoInstance::PaintFinished(int32_t result, int picture_buffer_id) {
   is_painting_ = false;
+  FinishGL();
   if (video_decoder_)
     video_decoder_->ReusePictureBuffer(picture_buffer_id);
 }
 
 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);
@@ skipping 124 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