Made Destroy() followup more aggressive to test for races.

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 68 matching lines @@
   // 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);
 
   // Decode helpers.
   void DecodeNextNALUs();
   void DecodeNextNALU();
   void GetNextNALUBoundary(size_t start_pos, size_t* end_pos);
   void Render(const PP_PictureBuffer_Dev& buffer);
+  void DeleteOutstandingBitstreamBuffers();
 
   // 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);
 
   // 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() {
@@ skipping 60 matching lines @@
   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();
   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();
 
@@ skipping 16 matching lines @@
   DecodeNextNALUs();
 }
 
 void GLES2DemoInstance::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) {
   // 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;
 }
@@ skipping 30 matching lines @@
   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);
     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(this, 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(
@@ skipping 229 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