Use explicit flush for ArcVideoAccelerator.

chrome/gpu/arc_gpu_video_decode_accelerator.cc

Index: chrome/gpu/arc_gpu_video_decode_accelerator.cc
diff --git a/chrome/gpu/arc_gpu_video_decode_accelerator.cc b/chrome/gpu/arc_gpu_video_decode_accelerator.cc
index b4b46b0da454249a619c6f9a6357041eeead1c85..272a4ae04aa61012a211482f3f82be234c388397 100644
--- a/chrome/gpu/arc_gpu_video_decode_accelerator.cc
+++ b/chrome/gpu/arc_gpu_video_decode_accelerator.cc
@@ -33,8 +33,7 @@ ArcGpuVideoDecodeAccelerator::InputBufferInfo::InputBufferInfo(
 ArcGpuVideoDecodeAccelerator::InputBufferInfo::~InputBufferInfo() {}
 
 ArcGpuVideoDecodeAccelerator::ArcGpuVideoDecodeAccelerator()
-    : pending_eos_output_buffer_(false),
-      arc_client_(nullptr),
+    : arc_client_(nullptr),
       next_bitstream_buffer_id_(0),
       output_buffer_size_(0) {}
 
@@ -208,13 +207,20 @@ void ArcGpuVideoDecodeAccelerator::UseBuffer(PortType port,
       vda_->Decode(media::BitstreamBuffer(
           bitstream_buffer_id, base::SharedMemoryHandle(dup_fd, true),
           metadata.bytes_used, input_info->offset));
-      if (metadata.flags & BUFFER_FLAG_EOS) {
-        vda_->Flush();
-      }
       break;
     }
     case PORT_OUTPUT: {
-      SendEosIfNeededOrReusePicture(index);
+      if (buffers_pending_import_[index].is_valid()) {

[Pawel Osciak, 2016/05/09 07:27:38]

Could you please add a comment explaining that if is_valid() == true, we
received this buffer from the Client via Bind*(), but this is the first time we
are passing it to the VDA, so need to import first?

[Owen Lin, 2016/05/10 08:26:33]

Done.

+        std::vector<gfx::GpuMemoryBufferHandle> buffers;

[Pawel Osciak, 2016/05/09 07:27:38]

Would std::vector<gfx::GpuMemoryBufferHandle> buffers(1); work?

[Owen Lin, 2016/05/10 08:26:33]

I will use the brace initialization syntax (suggested by dcheng) instead.

+        buffers.push_back(gfx::GpuMemoryBufferHandle());
+#if defined(USE_OZONE)
+        buffers.back().native_pixmap_handle.fd = base::FileDescriptor(
+            buffers_pending_import_[index].release(), true);

[dcheng, 2016/05/07 06:18:11]

Out of curiosity, how does this actually get fd get closed eventually?
base::FileDescriptor's "ownership" is merely advisory.

[Owen Lin, 2016/05/09 07:04:41]

posciak@ should know more about why choosing "GpuMemoryBufferHandle" to pass the
FD. In my understanding, VDA is not an interface for Posix system only. Using
GpuMemoryBufferHandle is a cross platform solution.

However, we only use it to pass the FD. In the implementation of
ImportBufferForPicture, the FD will be managed by ScopedFD again.

For example: 
https://code.google.com/p/chromium/codesearch#chromium/src/media/gpu/v4l2_sli...

[Pawel Osciak, 2016/05/09 07:27:38]

The contract is that the implementation of ImportBufferForPicture() will take
ownership and close the fd (please see
https://code.google.com/p/chromium/codesearch#chromium/src/media/video/video_...).

+#endif
+        vda_->ImportBufferForPicture(index, buffers);
+      } else {
+        vda_->ReusePictureBuffer(index);
+      }
       break;
     }
     default:
@@ -231,6 +237,15 @@ void ArcGpuVideoDecodeAccelerator::Reset() {
   vda_->Reset();
 }
 
+void ArcGpuVideoDecodeAccelerator::Flush() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!vda_) {
+    DLOG(ERROR) << "VDA not initialized";
+    return;
+  }
+  vda_->Flush();
+}
+
 void ArcGpuVideoDecodeAccelerator::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     uint32_t textures_per_buffer,
@@ -283,11 +298,6 @@ void ArcGpuVideoDecodeAccelerator::PictureReady(const media::Picture& picture) {
            << ", bitstream_buffer_id=" << picture.bitstream_buffer_id();
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // Empty buffer, returned in Flushing.
-  if (picture.bitstream_buffer_id() == -1) {
-    buffers_pending_eos_.push(picture.picture_buffer_id());
-    return;
-  }
   InputRecord* input_record = FindInputRecord(picture.bitstream_buffer_id());
   if (input_record == nullptr) {
     DLOG(ERROR) << "Cannot find for bitstream buffer id: "
@@ -317,11 +327,7 @@ void ArcGpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
 
 void ArcGpuVideoDecodeAccelerator::NotifyFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  pending_eos_output_buffer_ = true;
-  while (!buffers_pending_eos_.empty()) {
-    SendEosIfNeededOrReusePicture(buffers_pending_eos_.front());
-    buffers_pending_eos_.pop();
-  }
+  arc_client_->OnFlushDone();
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyResetDone() {
@@ -353,28 +359,6 @@ void ArcGpuVideoDecodeAccelerator::NotifyError(
   arc_client_->OnError(ConvertErrorCode(error));
 }
 
-void ArcGpuVideoDecodeAccelerator::SendEosIfNeededOrReusePicture(
-    uint32_t index) {
-  if (pending_eos_output_buffer_) {
-    BufferMetadata metadata;
-    metadata.flags = BUFFER_FLAG_EOS;
-    arc_client_->OnBufferDone(PORT_OUTPUT, index, metadata);
-    pending_eos_output_buffer_ = false;
-  } else {
-    if (buffers_pending_import_[index].is_valid()) {
-      std::vector<gfx::GpuMemoryBufferHandle> buffers;
-      buffers.push_back(gfx::GpuMemoryBufferHandle());
-#if defined(USE_OZONE)
-      buffers.back().native_pixmap_handle.fd =
-          base::FileDescriptor(buffers_pending_import_[index].release(), true);
-#endif
-      vda_->ImportBufferForPicture(index, buffers);
-    } else {
-      vda_->ReusePictureBuffer(index);
-    }
-  }
-}
-
 void ArcGpuVideoDecodeAccelerator::CreateInputRecord(
     int32_t bitstream_buffer_id,
     uint32_t buffer_index,