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

content/common/gpu/media/omx_video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
@@ skipping 427 matching lines @@
 
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class EglRenderingVDAClient : public VideoDecodeAccelerator::Client {
  public:
   // Doesn't take ownership of |note| or |encoded_data|, which must outlive
   // |*this|.
   EglRenderingVDAClient(RenderingHelper* rendering_helper,
                         int rendering_window_id,
                         ClientStateNotification* note,
-                        std::string* encoded_data,
+                        const std::string& encoded_data,
                         int num_NALUs_per_decode,
                         int delete_decoder_state);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(
       uint32 requested_num_of_buffers,
       const gfx::Size& dimensions);
@@ skipping 26 matching lines @@
 
   // Compute & return in |*end_pos| the end position for the next batch of NALUs
   // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
   void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
 
   // Request decode of the next batch of NALUs in the encoded data.
   void DecodeNextNALUs();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
-  const std::string* encoded_data_;
+  std::string encoded_data_;
   const int num_NALUs_per_decode_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification* note_;
   scoped_refptr<OmxVideoDecodeAccelerator> decoder_;
+  std::set<int> outstanding_texture_ids_;
   int delete_decoder_state_;
   ClientState state_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   base::TimeTicks last_frame_delivered_ticks_;
 };
 
 EglRenderingVDAClient::EglRenderingVDAClient(RenderingHelper* rendering_helper,
                                              int rendering_window_id,
                                              ClientStateNotification* note,
-                                             std::string* encoded_data,
+                                             const std::string& encoded_data,
                                              int num_NALUs_per_decode,
                                              int delete_decoder_state)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
       encoded_data_(encoded_data), num_NALUs_per_decode_(num_NALUs_per_decode),
       encoded_data_next_pos_to_decode_(0), next_bitstream_buffer_id_(0),
       note_(note), delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_decoded_frames_(0), num_done_bitstream_buffers_(0) {
   CHECK_GT(num_NALUs_per_decode, 0);
@@ skipping 31 matching lines @@
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 id = picture_buffers_by_id_.size();
     GLuint texture_id;
     base::WaitableEvent done(false, false);
     rendering_helper_->CreateTexture(rendering_window_id_, &texture_id, &done);
     done.Wait();
+    bool inserted = outstanding_texture_ids_.insert(texture_id).second;
+    DCHECK(inserted);

[vrk (LEFT CHROMIUM), 2011/07/26 17:33:20]

nit: change DCHECK to CHECK here and elsewhere.

[Ami GONE FROM CHROMIUM, 2011/07/26 18:05:09]

Done.

     media::PictureBuffer* buffer =
         new media::PictureBuffer(id, dimensions, texture_id);
     CHECK(picture_buffers_by_id_.insert(std::make_pair(id, buffer)).second);
     buffers.push_back(*buffer);
   }
   decoder_->AssignPictureBuffers(buffers);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 }
 
 void EglRenderingVDAClient::DismissPictureBuffer(int32 picture_buffer_id) {
   PictureBufferById::iterator it =
       picture_buffers_by_id_.find(picture_buffer_id);
   DCHECK(it != picture_buffers_by_id_.end());
+  int removed = outstanding_texture_ids_.erase(it->second->texture_id());
+  DCHECK_EQ(removed, 1);
   rendering_helper_->DeleteTexture(it->second->texture_id());
   delete it->second;
   picture_buffers_by_id_.erase(it);
 }
 
 void EglRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   DCHECK_LT(state_, CS_RESET);
 
   if (decoder_deleted())
@@ skipping 66 matching lines @@
     CHECK(!decoder_deleted());
     DeleteDecoder();
   }
 }
 
 void EglRenderingVDAClient::DeleteDecoder() {
   if (decoder_deleted())
     return;
   decoder_->Destroy();
   decoder_ = NULL;
+  STLClearObject(&encoded_data_);
+  for (std::set<int>::iterator it = outstanding_texture_ids_.begin();
+       it != outstanding_texture_ids_.end(); ++it) {
+    rendering_helper_->DeleteTexture(*it);
+  }
+  outstanding_texture_ids_.clear();
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
 void EglRenderingVDAClient::GetRangeForNextNALUs(
     size_t start_pos, size_t* end_pos) {
   *end_pos = start_pos;
-  CHECK(LookingAtNAL(*encoded_data_, start_pos));
+  CHECK(LookingAtNAL(encoded_data_, start_pos));
   for (int i = 0; i < num_NALUs_per_decode_; ++i) {
     *end_pos += 4;
-    while (*end_pos + 3 < encoded_data_->size() &&
-           !LookingAtNAL(*encoded_data_, *end_pos)) {
+    while (*end_pos + 3 < encoded_data_.size() &&
+           !LookingAtNAL(encoded_data_, *end_pos)) {
       ++*end_pos;
     }
-    if (*end_pos + 3 >= encoded_data_->size()) {
-      *end_pos = encoded_data_->size();
+    if (*end_pos + 3 >= encoded_data_.size()) {
+      *end_pos = encoded_data_.size();
       return;
     }
   }
 }
 
 void EglRenderingVDAClient::DecodeNextNALUs() {
   if (decoder_deleted())
     return;
-  if (encoded_data_next_pos_to_decode_ == encoded_data_->size()) {
+  if (encoded_data_next_pos_to_decode_ == encoded_data_.size()) {
     decoder_->Flush();
     return;
   }
   size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
   GetRangeForNextNALUs(start_pos, &end_pos);
 
   // Populate the shared memory buffer w/ the NALU, duplicate its handle, and
   // hand it off to the decoder.
   base::SharedMemory shm;
   CHECK(shm.CreateAndMapAnonymous(end_pos - start_pos))
       << start_pos << ", " << end_pos;
-  memcpy(shm.memory(), encoded_data_->data() + start_pos, end_pos - start_pos);
+  memcpy(shm.memory(), encoded_data_.data() + start_pos, end_pos - start_pos);
   base::SharedMemoryHandle dup_handle;
   CHECK(shm.ShareToProcess(base::Process::Current().handle(), &dup_handle));
   media::BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, dup_handle, end_pos - start_pos);
   decoder_->Decode(bitstream_buffer);
   encoded_data_next_pos_to_decode_ = end_pos;
 
   if (-delete_decoder_state_ == next_bitstream_buffer_id_)
     DeleteDecoder();
 }
@@ skipping 76 matching lines @@
                  suppress_swap_to_display, num_concurrent_decoders,
                  frame_width, frame_height, &done));
   done.Wait();
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     ClientStateNotification* note = new ClientStateNotification();
     notes[index] = note;
     EglRenderingVDAClient* client = new EglRenderingVDAClient(
         &rendering_helper, index,
-        note, &data_str, num_NALUs_per_decode,
+        note, data_str, num_NALUs_per_decode,
         delete_decoder_state);
     clients[index] = client;
 
     rendering_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&EglRenderingVDAClient::CreateDecoder,
                    base::Unretained(client)));
 
     ASSERT_EQ(note->Wait(), CS_DECODER_SET);
   }
@@ skipping 108 matching lines @@
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
       test_video_data = it->second.c_str();
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   return RUN_ALL_TESTS();
 }