Remove reliance on VideoToolbox frame ordering.

content/common/gpu/media/vt_video_decode_accelerator.cc

 // Copyright 2014 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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 487 matching lines @@
   } else {
     Frame* frame = reinterpret_cast<Frame*>(source_frame_refcon);
     frame->image.reset(image_buffer, base::scoped_policy::RETAIN);
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::DecodeDone, weak_this_, frame));
   }
 }
 
 void VTVideoDecodeAccelerator::DecodeDone(Frame* frame) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(frame->bitstream_id, pending_frames_.front()->bitstream_id);
+  DCHECK_EQ(1u, pending_frames_.count(frame));
   Task task(TASK_FRAME);
-  task.frame = pending_frames_.front();
-  pending_frames_.pop();
+  task.frame = pending_frames_[frame];
+  pending_frames_.erase(frame);
   task_queue_.push(task);
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::FlushTask(TaskType type) {
   DCHECK(decoder_thread_.message_loop_proxy()->BelongsToCurrentThread());
   FinishDelayedFrames();
 
   // Always queue a task, even if FinishDelayedFrames() fails, so that
   // destruction always completes.
   gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
       &VTVideoDecodeAccelerator::FlushDone, weak_this_, type));
 }
 
 void VTVideoDecodeAccelerator::FlushDone(TaskType type) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   task_queue_.push(Task(type));
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::Decode(const media::BitstreamBuffer& bitstream) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(assigned_bitstream_ids_.count(bitstream.id()), 0u);
+  DCHECK_EQ(0u, assigned_bitstream_ids_.count(bitstream.id()));
   assigned_bitstream_ids_.insert(bitstream.id());
   Frame* frame = new Frame(bitstream.id());
-  pending_frames_.push(make_linked_ptr(frame));
+  pending_frames_[frame] = make_linked_ptr(frame);
   decoder_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
       &VTVideoDecodeAccelerator::DecodeTask, base::Unretained(this),
       bitstream, frame));
 }
 
 void VTVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& pictures) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   for (const media::PictureBuffer& picture : pictures) {
@@ skipping 244 matching lines @@
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content