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

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc

Index: media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc
diff --git a/media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc b/media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc
index 2bafbeebd11dc9edb24216dc748d8c79ac9d82a4..af17901fcaca1e61120918612456896cd798b2cf 100644
--- a/media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc
+++ b/media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc
@@ -10,7 +10,6 @@
 #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"
@@ -22,9 +21,7 @@
 #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"
 
@@ -62,12 +59,6 @@
   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
@@ -103,22 +94,17 @@
 
 namespace media {
 
-class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client {
+class GpuJpegDecodeAccelerator::Client : public JpegDecodeAccelerator::Client,
+                                         public base::NonThreadSafe {
  public:
-  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(thread_checker_.CalledOnValidThread()); }
+  Client(GpuJpegDecodeAccelerator* owner, int32_t route_id)
+      : owner_(owner->AsWeakPtr()), route_id_(route_id) {}
+
+  ~Client() override { DCHECK(CalledOnValidThread()); }
 
   // JpegDecodeAccelerator::Client implementation.
   void VideoFrameReady(int32_t bitstream_buffer_id) override {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK(CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id,
                                  JpegDecodeAccelerator::NO_ERRORS);
@@ -126,34 +112,31 @@
 
   void NotifyError(int32_t bitstream_buffer_id,
                    JpegDecodeAccelerator::Error error) override {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK(CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id, error);
   }
 
   void Decode(const BitstreamBuffer& bitstream_buffer,
               const scoped_refptr<VideoFrame>& video_frame) {
-    DCHECK(io_task_runner_->BelongsToCurrentThread());
+    DCHECK(CalledOnValidThread());
     DCHECK(accelerator_);
     accelerator_->Decode(bitstream_buffer, video_frame);
   }
 
   void set_accelerator(std::unique_ptr<JpegDecodeAccelerator> accelerator) {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    DCHECK(CalledOnValidThread());
     accelerator_ = std::move(accelerator);
   }
 
  private:
-  base::ThreadChecker thread_checker_;
   base::WeakPtr<GpuJpegDecodeAccelerator> owner_;
-  const int32_t route_id_;
-  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  int32_t route_id_;
   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)
@@ -348,13 +331,8 @@
 GpuJpegDecodeAcceleratorFactoryProvider::GetAcceleratorFactories() {
   // This list is ordered by priority of use.
   std::vector<CreateAcceleratorCB> result;
-  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));
-  }
+  result.push_back(base::Bind(&CreateV4L2JDA));
+  result.push_back(base::Bind(&CreateVaapiJDA));
   return result;
 }
 
@@ -391,8 +369,7 @@
   // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize
   // needs to be updated.
 
-  std::unique_ptr<Client> client(
-      new Client(AsWeakPtr(), route_id, io_task_runner_));
+  std::unique_ptr<Client> client(new Client(this, route_id));
   std::unique_ptr<JpegDecodeAccelerator> accelerator;
   for (const auto& create_jda_function : accelerator_factory_functions_) {
     std::unique_ptr<JpegDecodeAccelerator> tmp_accelerator =