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

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc

 // Copyright 2015 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/ipc/service/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.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 "gpu/ipc/service/gpu_channel.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
+#include "media/base/media_switches.h"
 #include "media/filters/jpeg_parser.h"
+#include "media/gpu/fake_jpeg_decode_accelerator.h"
 #include "media/gpu/ipc/common/media_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_jpeg_decode_accelerator.h"
 #endif
 #if defined(USE_V4L2_CODEC)
 #include "media/gpu/v4l2_device.h"
 #include "media/gpu/v4l2_jpeg_decode_accelerator.h"
@@ skipping 17 matching lines @@
 std::unique_ptr<media::JpegDecodeAccelerator> CreateVaapiJDA(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
   std::unique_ptr<media::JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   decoder.reset(
       new media::VaapiJpegDecodeAccelerator(std::move(io_task_runner)));
 #endif
   return decoder;
 }
 
+std::unique_ptr<media::JpegDecodeAccelerator> CreateFakeJDA(
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
+  return base::MakeUnique<media::FakeJpegDecodeAccelerator>(
+      std::move(io_task_runner));
+}
+
 void DecodeFinished(std::unique_ptr<base::SharedMemory> shm) {
   // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this
   // function is to just keep reference of |shm| to make sure it lives until
   // decode finishes.
 }
 
 bool VerifyDecodeParams(const AcceleratedJpegDecoderMsg_Decode_Params& params) {
   const int kJpegMaxDimension = UINT16_MAX;
   if (params.coded_size.IsEmpty() ||
       params.coded_size.width() > kJpegMaxDimension ||
@@ skipping 15 matching lines @@
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace media {
 
-class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client,
-                                         public base::NonThreadSafe {
+class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client {
  public:
-  Client(GpuJpegDecodeAccelerator* owner, int32_t route_id)
-      : owner_(owner->AsWeakPtr()), route_id_(route_id) {}
+  Client(base::WeakPtr<GpuJpegDecodeAccelerator> owner,
+         int32_t route_id,
+         scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+      : owner_(std::move(owner)),
+        route_id_(route_id),
+        io_task_runner_(std::move(io_task_runner)) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+  }
 
-  ~Client() override { DCHECK(CalledOnValidThread()); }
+  ~Client() override { DCHECK(thread_checker_.CalledOnValidThread()); }
 
   // JpegDecodeAccelerator::Client implementation.
   void VideoFrameReady(int32_t bitstream_buffer_id) override {
-    DCHECK(CalledOnValidThread());
+    DCHECK(thread_checker_.CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id,
                                  JpegDecodeAccelerator::NO_ERRORS);
   }
 
   void NotifyError(int32_t bitstream_buffer_id,
                    JpegDecodeAccelerator::Error error) override {
-    DCHECK(CalledOnValidThread());
+    DCHECK(thread_checker_.CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, error);
   }
 
   void Decode(const BitstreamBuffer& bitstream_buffer,
               const scoped_refptr<VideoFrame>& video_frame) {
-    DCHECK(CalledOnValidThread());
+    DCHECK(io_task_runner_->BelongsToCurrentThread());
     DCHECK(accelerator_);
     accelerator_->Decode(bitstream_buffer, video_frame);
   }
 
   void set_accelerator(std::unique_ptr<JpegDecodeAccelerator> accelerator) {
-    DCHECK(CalledOnValidThread());
+    DCHECK(thread_checker_.CalledOnValidThread());
     accelerator_ = std::move(accelerator);
   }
 
  private:
+  base::ThreadChecker thread_checker_;
   base::WeakPtr<GpuJpegDecodeAccelerator> owner_;
-  int32_t route_id_;
+  const int32_t route_id_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   std::unique_ptr<JpegDecodeAccelerator> accelerator_;
 };
 
 // Create, destroy, and RemoveClient run on child thread. All other methods run
 // on IO thread.
+// TODO(chfremer): Migrate this to Mojo. See https://crbug.com/699255
 class GpuJpegDecodeAccelerator::MessageFilter : public IPC::MessageFilter {
  public:
   explicit MessageFilter(GpuJpegDecodeAccelerator* owner)
       : owner_(owner->AsWeakPtr()),
         child_task_runner_(owner_->child_task_runner_),
         io_task_runner_(owner_->io_task_runner_) {}
 
   void OnChannelError() override { sender_ = nullptr; }
 
   void OnChannelClosing() override { sender_ = nullptr; }
@@ skipping 174 matching lines @@
       return true;
   }
   return false;
 }
 
 // static
 std::vector<GpuJpegDecodeAcceleratorFactoryProvider::CreateAcceleratorCB>
 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories() {
   // This list is ordered by priority of use.
   std::vector<CreateAcceleratorCB> result;
-  result.push_back(base::Bind(&CreateV4L2JDA));
-  result.push_back(base::Bind(&CreateVaapiJDA));
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseFakeJpegDecodeAccelerator)) {
+    result.push_back(base::Bind(&CreateFakeJDA));
+  } else {
+    result.push_back(base::Bind(&CreateV4L2JDA));
+    result.push_back(base::Bind(&CreateVaapiJDA));
+  }
   return result;
 }
 
 GpuJpegDecodeAccelerator::GpuJpegDecodeAccelerator(
     gpu::FilteredSender* channel,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : GpuJpegDecodeAccelerator(
           channel,
           std::move(io_task_runner),
           GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories()) {}
@@ skipping 16 matching lines @@
   }
 }
 
 void GpuJpegDecodeAccelerator::AddClient(int32_t route_id,
                                          base::Callback<void(bool)> response) {
   DCHECK(CalledOnValidThread());
 
   // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize
   // needs to be updated.
 
-  std::unique_ptr<Client> client(new Client(this, route_id));
+  std::unique_ptr<Client> client(
+      new Client(AsWeakPtr(), route_id, io_task_runner_));
   std::unique_ptr<JpegDecodeAccelerator> accelerator;
   for (const auto& create_jda_function : accelerator_factory_functions_) {
     std::unique_ptr<JpegDecodeAccelerator> tmp_accelerator =
         create_jda_function.Run(io_task_runner_);
     if (tmp_accelerator && tmp_accelerator->Initialize(client.get())) {
       accelerator = std::move(tmp_accelerator);
       break;
     }
   }
 
@@ skipping 40 matching lines @@
     filter_ = nullptr;
   }
 }
 
 bool GpuJpegDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   return channel_->Send(message);
 }
 
 }  // namespace media