Fix PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer to use correct ID.

webkit/plugins/ppapi/ppb_video_decoder_impl.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 "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 45 matching lines @@
     current++;
   }
 }
 
 }  // namespace
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PluginInstance* instance)
     : Resource(instance),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       abort_callback_(PP_BlockUntilComplete()),
-      flush_callback_(PP_BlockUntilComplete()),
-      bitstream_buffer_callback_(PP_BlockUntilComplete()) {
+      flush_callback_(PP_BlockUntilComplete()) {
   ppp_videodecoder_ =
       static_cast<const PPP_VideoDecoder_Dev*>(instance->module()->
           GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
 }
 
 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
 }
 
 // static
 PP_Resource PPB_VideoDecoder_Impl::Create(PP_Instance pp_instance) {
@@ skipping 81 matching lines @@
 
   ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_Buffer_API>
       enter(bitstream_buffer->data, true);
   if (enter.failed())
     return PP_ERROR_FAILED;
 
   PPB_Buffer_Impl* buffer = static_cast<PPB_Buffer_Impl*>(enter.object());
   media::BitstreamBuffer decode_buffer(bitstream_buffer->id,
                                        buffer->shared_memory()->handle(),
                                        static_cast<size_t>(buffer->size()));
-
-  // Store the callback to inform when bitstream buffer has been processed.
-  // TODO(vmr): handle simultaneous decodes + callbacks.
-  bitstream_buffer_callback_ = callback;
+  CHECK(bitstream_buffer_callbacks_.insert(std::make_pair(
+      bitstream_buffer->id, callback)).second);
 
   if (platform_video_decoder_->Decode(decode_buffer))
     return PP_OK_COMPLETIONPENDING;
   else
     return PP_ERROR_FAILED;
 }
 
 void PPB_VideoDecoder_Impl::AssignGLESBuffers(
     uint32_t no_of_buffers,
     const PP_GLESBuffer_Dev* buffers) {
@@ skipping 121 matching lines @@
 void PPB_VideoDecoder_Impl::NotifyAbortDone() {
   if (abort_callback_.func == NULL)
     return;
 
   // Call the callback that was stored to be called when Abort is done.
   PP_RunAndClearCompletionCallback(&abort_callback_, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
-  if (bitstream_buffer_callback_.func == NULL)
-    return;
-
-  // Call the callback that was stored to be called when bitstream was sent for
-  // decoding.
-  PP_RunAndClearCompletionCallback(&bitstream_buffer_callback_, PP_OK);
+  CallbackById::iterator it =
+      bitstream_buffer_callbacks_.find(bitstream_buffer_id);
+  DCHECK(it != bitstream_buffer_callbacks_.end());
+  PP_CompletionCallback cc = it->second;
+  bitstream_buffer_callbacks_.erase(it);
+  PP_RunCompletionCallback(&cc, PP_OK);
 }
 
 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
   if (flush_callback_.func == NULL)
     return;
 
   // Call the callback that was stored to be called when Flush is done.
   PP_RunAndClearCompletionCallback(&flush_callback_, PP_OK);
 }
 
@@ skipping 32 matching lines @@
 }
 
 Picture::Picture(const PP_Picture_Dev& picture)
     : picture_buffer_id_(picture.picture_buffer_id),
       bitstream_buffer_id_(picture.bitstream_buffer_id),
       visible_size_(picture.visible_size.width, picture.visible_size.height),
       decoded_size_(picture.decoded_size.width, picture.decoded_size.height) {
 }
 
 }  // namespace media