Don't dismiss picture buffers on rez change until they are available

content/common/gpu/media/dxva_video_decode_accelerator.cc

 // Copyright (c) 2012 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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 540 matching lines @@
     FlushInternal();
 }
 
 void DXVAVideoDecodeAccelerator::ReusePictureBuffer(
     int32 picture_buffer_id) {
   DCHECK(CalledOnValidThread());
 
   RETURN_AND_NOTIFY_ON_FAILURE((state_ != kUninitialized),
       "Invalid state: " << state_, ILLEGAL_STATE,);
 
-  if (output_picture_buffers_.empty())
+  if (output_picture_buffers_.empty() && stale_output_picture_buffers_.empty())
     return;
 
   OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
-  RETURN_AND_NOTIFY_ON_FAILURE(it != output_picture_buffers_.end(),
-      "Invalid picture id: " << picture_buffer_id, INVALID_ARGUMENT,);
+  // If we didn't find the picture id in the |output_picture_buffers_| map we
+  // try the |stale_output_picture_buffers_| map, as this may have been an
+  // output picture buffer from before a resolution change, that at resolution
+  // change time had yet to be displayed. The client is calling us back to tell
+  // us that we can now recycle this picture buffer, so if we were waiting to
+  // dispose of it we now can.
+  if (it == output_picture_buffers_.end()) {
+    it = stale_output_picture_buffers_.find(picture_buffer_id);
+    RETURN_AND_NOTIFY_ON_FAILURE(it != stale_output_picture_buffers_.end(),
+        "Invalid picture id: " << picture_buffer_id, INVALID_ARGUMENT,);
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(&DXVAVideoDecodeAccelerator::DeferredDismissStaleBuffer,
+            weak_this_factory_.GetWeakPtr(), picture_buffer_id));
+    return;
+  }
 
   it->second->ReusePictureBuffer();
   ProcessPendingSamples();
 
   if (state_ == kFlushing && pending_output_samples_.empty())
     FlushInternal();
 }
 
 void DXVAVideoDecodeAccelerator::Flush() {
   DCHECK(CalledOnValidThread());
@@ skipping 412 matching lines @@
   if (state_ != kUninitialized) {
     Invalidate();
   }
 }
 
 void DXVAVideoDecodeAccelerator::Invalidate() {
   if (state_ == kUninitialized)
     return;
   weak_this_factory_.InvalidateWeakPtrs();
   output_picture_buffers_.clear();
+  stale_output_picture_buffers_.clear();
   pending_output_samples_.clear();
   pending_input_buffers_.clear();
   decoder_.Release();
   MFShutdown();
   state_ = kUninitialized;
 }
 
 void DXVAVideoDecodeAccelerator::NotifyInputBufferRead(int input_buffer_id) {
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
@@ skipping 156 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::NotifyInputBufferRead,
                  weak_this_factory_.GetWeakPtr(),
                  input_buffer_id));
 }
 
 void DXVAVideoDecodeAccelerator::HandleResolutionChanged(int width,
                                                          int height) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DismissStaleBuffers,
-                 weak_this_factory_.GetWeakPtr(),
-                 output_picture_buffers_));
+                 weak_this_factory_.GetWeakPtr()));
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::RequestPictureBuffers,
                  weak_this_factory_.GetWeakPtr(),
                  width,
                  height));
+}
+
+void DXVAVideoDecodeAccelerator::DismissStaleBuffers() {
+  OutputBuffers::iterator index;
+
+  for (index = output_picture_buffers_.begin();
+       index != output_picture_buffers_.end();
+       ++index) {
+    if (index->second->available()) {
+      DVLOG(1) << "Dismissing picture id: " << index->second->id();
+      client_->DismissPictureBuffer(index->second->id());
+    } else {
+      // Move to |stale_output_picture_buffers_| for deferred deletion.
+      stale_output_picture_buffers_.insert(
+          std::make_pair(index->first, index->second));
+    }
+  }
 
   output_picture_buffers_.clear();
 }
 
-void DXVAVideoDecodeAccelerator::DismissStaleBuffers(
-    const OutputBuffers& picture_buffers) {
-  OutputBuffers::const_iterator index;
-
-  for (index = picture_buffers.begin();
-       index != picture_buffers.end();
-       ++index) {
-    DVLOG(1) << "Dismissing picture id: " << index->second->id();
-    client_->DismissPictureBuffer(index->second->id());
-  }
+void DXVAVideoDecodeAccelerator::DeferredDismissStaleBuffer(
+    int32 picture_buffer_id) {
+  OutputBuffers::iterator it = stale_output_picture_buffers_.find(
+      picture_buffer_id);
+  DCHECK(it != stale_output_picture_buffers_.end());
+  DVLOG(1) << "Dismissing picture id: " << it->second->id();
+  client_->DismissPictureBuffer(it->second->id());
+  stale_output_picture_buffers_.erase(it);
 }
 
 }  // namespace content