[Mojo Video Capture] Add test coverage for accelerated jpeg decoding

media/gpu/fake_jpeg_decode_accelerator.cc

Index: media/gpu/fake_jpeg_decode_accelerator.cc
diff --git a/media/gpu/fake_jpeg_decode_accelerator.cc b/media/gpu/fake_jpeg_decode_accelerator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..af6dc52cb2a0dced1a2b216c3316c4885eebe732
--- /dev/null
+++ b/media/gpu/fake_jpeg_decode_accelerator.cc
@@ -0,0 +1,104 @@
+// Copyright 2017 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/fake_jpeg_decode_accelerator.h"
+
+#include "base/bind.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "media/filters/jpeg_parser.h"
+#include "media/gpu/shared_memory_region.h"
+#include "third_party/libyuv/include/libyuv.h"
+
+namespace media {
+
+FakeJpegDecodeAccelerator::FakeJpegDecodeAccelerator(
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(std::move(io_task_runner)),
+      weak_factory_(this) {}
+
+FakeJpegDecodeAccelerator::~FakeJpegDecodeAccelerator() = default;
+
+bool FakeJpegDecodeAccelerator::Initialize(
+    JpegDecodeAccelerator::Client* client) {
+  client_ = client;
+  return true;
+}
+
+void FakeJpegDecodeAccelerator::Decode(
+    const BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<VideoFrame>& video_frame) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  // SharedMemoryRegion will take over the |bitstream_buffer.handle()|.
+  std::unique_ptr<SharedMemoryRegion> src_shm_(
+      new SharedMemoryRegion(bitstream_buffer, true));
+  if (!src_shm_->Map()) {
+    DLOG(ERROR) << "Unable to map shared memory in FakeJpegDecodeAccelerator";
+    NotifyErrorFromIoThread(bitstream_buffer.id(),
+                            JpegDecodeAccelerator::UNREADABLE_INPUT);
+    return;
+  }
+
+  JpegParseResult parse_result;
+  if (!ParseJpegPicture(static_cast<uint8_t*>(src_shm_->memory()),
+                        src_shm_->size(), &parse_result)) {
+    DLOG(ERROR) << "ParseJpegPicture failed in FakeJpegDecodeAccelerator";
+    NotifyErrorFromIoThread(bitstream_buffer.id(),
+                            JpegDecodeAccelerator::PARSE_JPEG_FAILED);
+    return;
+  }
+  gfx::Size src_coded_size(parse_result.frame_header.coded_width,

[mcasas, 2017/03/07 19:39:38]

nit: const.

[chfremer, 2017/03/07 22:30:38]

Done.

+                           parse_result.frame_header.coded_height);
+  DCHECK_GE(src_coded_size.width(), video_frame->coded_size().width());
+  DCHECK_GE(src_coded_size.height(), video_frame->coded_size().height());
+
+  uint8_t* dst_y = video_frame->data(VideoFrame::kYPlane);
+  uint8_t* dst_u = video_frame->data(VideoFrame::kUPlane);
+  uint8_t* dst_v = video_frame->data(VideoFrame::kVPlane);
+  size_t dst_y_stride = video_frame->stride(VideoFrame::kYPlane);
+  size_t dst_u_stride = video_frame->stride(VideoFrame::kUPlane);
+  size_t dst_v_stride = video_frame->stride(VideoFrame::kVPlane);
+
+  if (libyuv::ConvertToI420(
+          static_cast<uint8_t*>(src_shm_->memory()), src_shm_->size(), dst_y,
+          dst_y_stride, dst_u, dst_u_stride, dst_v, dst_v_stride, 0, 0,
+          src_coded_size.width(), src_coded_size.height(),
+          video_frame->coded_size().width(), video_frame->coded_size().height(),
+          libyuv::kRotate0, libyuv::FOURCC_MJPG) != 0) {
+    LOG(ERROR) << "Software decode failed.";

[mcasas, 2017/03/07 19:39:38]

s/LOG/DLOG/ for consistency.  Note that
release bots compile with debug logs on.

[chfremer, 2017/03/07 22:30:38]

Done.

+    NotifyErrorFromIoThread(bitstream_buffer.id(),
+                            JpegDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeJpegDecodeAccelerator::OnDecodeDoneOnClientThread,
+                 weak_factory_.GetWeakPtr(), bitstream_buffer.id()));
+}
+
+bool FakeJpegDecodeAccelerator::IsSupported() {
+  return true;
+}
+
+void FakeJpegDecodeAccelerator::NotifyErrorFromIoThread(
+    int32_t bitstream_buffer_id,

[mcasas, 2017/03/07 19:39:38]

s/NotifyErrorFromIoThread/NotifyError/ 

same as Decode(), we don't need a from-thread indication
beyond the DCHECK in l.87.

[chfremer, 2017/03/07 22:30:38]

Done.

+    Error error) {
+  task_runner_->PostTask(

[mcasas, 2017/03/07 19:39:38]

DCHECK(io_task_runner_->BelongsToCurrentThread()); ?

[chfremer, 2017/03/07 22:30:38]

Done.

+      FROM_HERE,
+      base::Bind(&FakeJpegDecodeAccelerator::OnNotifyErrorOnClientThread,
+                 weak_factory_.GetWeakPtr(), bitstream_buffer_id, error));
+}
+
+void FakeJpegDecodeAccelerator::OnNotifyErrorOnClientThread(

[mcasas, 2017/03/07 19:39:38]

s/OnNotifyErrorOnClientThread/NotifyErrorOnClientThread/

[chfremer, 2017/03/07 22:30:38]

Done.

+    int32_t bitstream_buffer_id,
+    Error error) {
+  client_->NotifyError(bitstream_buffer_id, error);

[mcasas, 2017/03/07 19:39:38]

Add DCHECK(task_runner_->BelongsToCurrentThread());

[chfremer, 2017/03/07 22:30:38]

Done.

+}
+
+void FakeJpegDecodeAccelerator::OnDecodeDoneOnClientThread(
+    int32_t input_buffer_id) {
+  client_->VideoFrameReady(input_buffer_id);

[mcasas, 2017/03/07 19:39:38]

Add DCHECK(task_runner_->BelongsToCurrentThread());

[chfremer, 2017/03/07 22:30:38]

Done.

+}
+
+}  // namespace media