V4L2VideoDecodeAccelerator: fix frame returned after processor destroys.

media/gpu/v4l2_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 "media/gpu/v4l2_video_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "media/filters/h264_parser.h"
 #include "media/gpu/shared_memory_region.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_binders.h"
 
 #define LOGF(level) LOG(level) << __FUNCTION__ << "(): "
 #define DLOGF(level) DLOG(level) << __FUNCTION__ << "(): "
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
@@ skipping 1184 matching lines @@
         image_processor_bitstream_buffer_ids_.push(bitstream_buffer_id);
         std::vector<int> fds;
         for (auto& fd : output_record.fds) {
           fds.push_back(fd.get());
         }
         scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalDmabufs(
             V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
             coded_size_, gfx::Rect(visible_size_), visible_size_, fds,
             base::TimeDelta());
         // Unretained is safe because |this| owns image processor and there will
-        // be no callbacks after processor destroys. Also, this class ensures it
-        // is safe to post a task from child thread to decoder thread using
-        // Unretained.
+        // be no callbacks after processor destroys.
         image_processor_->Process(
             frame, dqbuf.index,
-            BindToCurrentLoop(
-                base::Bind(&V4L2VideoDecodeAccelerator::FrameProcessed,
-                           base::Unretained(this), bitstream_buffer_id)));
+            base::Bind(&V4L2VideoDecodeAccelerator::FrameProcessed,
+                       base::Unretained(this), bitstream_buffer_id));
       } else {
         output_record.state = kAtClient;
         decoder_frames_at_client_++;
         const Picture picture(output_record.picture_id, bitstream_buffer_id,
                               gfx::Rect(visible_size_), false);
         pending_picture_ready_.push(
             PictureRecord(output_record.cleared, picture));
         SendPictureReady();
         output_record.cleared = true;
       }
@@ skipping 1041 matching lines @@
       Enqueue();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOGF(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media