Replace deprecated base::NonThreadSafe in media/gpu in favor of SequenceChecker.

Note to crash team: This CL is a refactor and has no intended behavior change.

This change was scripted by https://crbug.com/676387#c8.

Note-worthy for the reviewer:
 * SequenceChecker enforces thread-safety but not thread-affinity!
   If the classes that were updated are thread-affine (use thread local
   storage or a third-party API that does) they should be migrated to
   ThreadChecker instead.
 * ~NonThreadSafe() used to implcitly check in its destructor
   ~Sequence/ThreadChecker() doesn't by design. To keep this CL a
   no-op, an explicit check was added to the destructor of migrated
   classes.
 * NonThreadSafe used to provide access to subclasses, as such
   the |sequence_checker_| member was made protected rather than
   private where necessary.

BUG=676387
This CL was uploaded by git cl split.

R=posciak@chromium.org
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel

Review-Url: https://codereview.chromium.org/2911113003
Cr-Commit-Position: refs/heads/master@{#476429}

media/gpu/ipc/client/gpu_jpeg_decode_accelerator_host.cc

@@ -24,8 +24,7 @@ namespace media {
 // Class to receive AcceleratedJpegDecoderHostMsg_DecodeAck IPC message on IO
 // thread. This does very similar what MessageFilter usually does. It is not
 // MessageFilter because GpuChannelHost doesn't support AddFilter.
-class GpuJpegDecodeAcceleratorHost::Receiver : public IPC::Listener,
-                                               public base::NonThreadSafe {
+class GpuJpegDecodeAcceleratorHost::Receiver : public IPC::Listener {
  public:
   Receiver(Client* client,
            const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
@@ -34,11 +33,11 @@ class GpuJpegDecodeAcceleratorHost::Receiver : public IPC::Listener,
         weak_factory_for_io_(
             base::MakeUnique<base::WeakPtrFactory<Receiver>>(this)),
         weak_ptr_for_io_(weak_factory_for_io_->GetWeakPtr()) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   }
 
   ~Receiver() override {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     // If |io_task_runner_| no longer accepts tasks, |weak_factory_for_io_|
     // will leak. This is acceptable, because that should only happen on
     // Browser shutdown.
@@ -96,6 +95,8 @@ class GpuJpegDecodeAcceleratorHost::Receiver : public IPC::Listener,
   // GPU IO task runner.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // Weak pointers will be invalidated on IO thread.
   std::unique_ptr<base::WeakPtrFactory<Receiver>> weak_factory_for_io_;
   base::WeakPtr<Receiver> weak_ptr_for_io_;
@@ -115,7 +116,7 @@ GpuJpegDecodeAcceleratorHost::GpuJpegDecodeAcceleratorHost(
 }
 
 GpuJpegDecodeAcceleratorHost::~GpuJpegDecodeAcceleratorHost() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Send(new AcceleratedJpegDecoderMsg_Destroy(decoder_route_id_));
 
   if (receiver_) {
@@ -140,7 +141,7 @@ GpuJpegDecodeAcceleratorHost::~GpuJpegDecodeAcceleratorHost() {
 
 bool GpuJpegDecodeAcceleratorHost::Initialize(
     JpegDecodeAccelerator::Client* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool succeeded = false;
   // This cannot be on IO thread because the msg is synchronous.
@@ -159,7 +160,7 @@ bool GpuJpegDecodeAcceleratorHost::Initialize(
 void GpuJpegDecodeAcceleratorHost::Decode(
     const BitstreamBuffer& bitstream_buffer,
     const scoped_refptr<VideoFrame>& video_frame) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(
       base::SharedMemory::IsHandleValid(video_frame->shared_memory_handle()));
@@ -202,7 +203,7 @@ bool GpuJpegDecodeAcceleratorHost::IsSupported() {
 }
 
 void GpuJpegDecodeAcceleratorHost::Send(IPC::Message* message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!channel_->Send(message)) {
     DLOG(ERROR) << "Send(" << message->type() << ") failed";

media/gpu/ipc/client/gpu_jpeg_decode_accelerator_host.h

@@ -11,7 +11,7 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/sequence_checker.h"
 #include "media/video/jpeg_decode_accelerator.h"
 
 namespace base {
@@ -31,8 +31,7 @@ namespace media {
 
 // This class is used to talk to JpegDecodeAccelerator in the GPU process
 // through IPC messages.
-class GpuJpegDecodeAcceleratorHost : public JpegDecodeAccelerator,
-                                     public base::NonThreadSafe {
+class GpuJpegDecodeAcceleratorHost : public JpegDecodeAccelerator {
  public:
   GpuJpegDecodeAcceleratorHost(
       scoped_refptr<gpu::GpuChannelHost> channel,
@@ -65,6 +64,8 @@ class GpuJpegDecodeAcceleratorHost : public JpegDecodeAccelerator,
 
   std::unique_ptr<Receiver> receiver_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(GpuJpegDecodeAcceleratorHost);
 };
 

media/gpu/ipc/client/gpu_video_decode_accelerator_host.cc

@@ -32,7 +32,7 @@ GpuVideoDecodeAcceleratorHost::GpuVideoDecodeAcceleratorHost(
 }
 
 GpuVideoDecodeAcceleratorHost::~GpuVideoDecodeAcceleratorHost() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (channel_ && decoder_route_id_ != MSG_ROUTING_NONE)
     channel_->RemoveRoute(decoder_route_id_);
@@ -43,7 +43,7 @@ GpuVideoDecodeAcceleratorHost::~GpuVideoDecodeAcceleratorHost() {
 }
 
 bool GpuVideoDecodeAcceleratorHost::OnMessageReceived(const IPC::Message& msg) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAcceleratorHost, msg)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderHostMsg_InitializationComplete,
@@ -69,7 +69,7 @@ bool GpuVideoDecodeAcceleratorHost::OnMessageReceived(const IPC::Message& msg) {
 }
 
 void GpuVideoDecodeAcceleratorHost::OnChannelError() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (channel_) {
     if (decoder_route_id_ != MSG_ROUTING_NONE)
       channel_->RemoveRoute(decoder_route_id_);
@@ -81,7 +81,7 @@ void GpuVideoDecodeAcceleratorHost::OnChannelError() {
 
 bool GpuVideoDecodeAcceleratorHost::Initialize(const Config& config,
                                                Client* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   client_ = client;
 
   base::AutoLock lock(impl_lock_);
@@ -107,7 +107,7 @@ bool GpuVideoDecodeAcceleratorHost::Initialize(const Config& config,
 
 void GpuVideoDecodeAcceleratorHost::Decode(
     const BitstreamBuffer& bitstream_buffer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   BitstreamBuffer buffer_to_send = bitstream_buffer;
@@ -124,7 +124,7 @@ void GpuVideoDecodeAcceleratorHost::Decode(
 
 void GpuVideoDecodeAcceleratorHost::AssignPictureBuffers(
     const std::vector<PictureBuffer>& buffers) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   // Rearrange data for IPC command.
@@ -148,7 +148,7 @@ void GpuVideoDecodeAcceleratorHost::AssignPictureBuffers(
 
 void GpuVideoDecodeAcceleratorHost::ReusePictureBuffer(
     int32_t picture_buffer_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   Send(new AcceleratedVideoDecoderMsg_ReusePictureBuffer(decoder_route_id_,
@@ -156,14 +156,14 @@ void GpuVideoDecodeAcceleratorHost::ReusePictureBuffer(
 }
 
 void GpuVideoDecodeAcceleratorHost::Flush() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   Send(new AcceleratedVideoDecoderMsg_Flush(decoder_route_id_));
 }
 
 void GpuVideoDecodeAcceleratorHost::Reset() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   Send(new AcceleratedVideoDecoderMsg_Reset(decoder_route_id_));
@@ -172,7 +172,7 @@ void GpuVideoDecodeAcceleratorHost::Reset() {
 void GpuVideoDecodeAcceleratorHost::SetSurface(
     int32_t surface_id,
     const base::Optional<base::UnguessableToken>& routing_token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
   Send(new AcceleratedVideoDecoderMsg_SetSurface(decoder_route_id_, surface_id,
@@ -180,7 +180,7 @@ void GpuVideoDecodeAcceleratorHost::SetSurface(
 }
 
 void GpuVideoDecodeAcceleratorHost::Destroy() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (channel_)
     Send(new AcceleratedVideoDecoderMsg_Destroy(decoder_route_id_));
   client_ = nullptr;
@@ -198,7 +198,7 @@ void GpuVideoDecodeAcceleratorHost::OnWillDeleteImpl() {
 }
 
 void GpuVideoDecodeAcceleratorHost::PostNotifyError(Error error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << "PostNotifyError(): error=" << error;
   media_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuVideoDecodeAcceleratorHost::OnNotifyError,
@@ -206,7 +206,7 @@ void GpuVideoDecodeAcceleratorHost::PostNotifyError(Error error) {
 }
 
 void GpuVideoDecodeAcceleratorHost::Send(IPC::Message* message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   uint32_t message_type = message->type();
   if (!channel_->Send(message)) {
     DLOG(ERROR) << "Send(" << message_type << ") failed";
@@ -215,14 +215,14 @@ void GpuVideoDecodeAcceleratorHost::Send(IPC::Message* message) {
 }
 
 void GpuVideoDecodeAcceleratorHost::OnInitializationComplete(bool success) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (client_)
     client_->NotifyInitializationComplete(success);
 }
 
 void GpuVideoDecodeAcceleratorHost::OnBitstreamBufferProcessed(
     int32_t bitstream_buffer_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
 }
@@ -233,7 +233,7 @@ void GpuVideoDecodeAcceleratorHost::OnProvidePictureBuffers(
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   picture_buffer_dimensions_ = dimensions;
 
   const int kMaxVideoPlanes = 4;
@@ -251,14 +251,14 @@ void GpuVideoDecodeAcceleratorHost::OnProvidePictureBuffers(
 
 void GpuVideoDecodeAcceleratorHost::OnDismissPictureBuffer(
     int32_t picture_buffer_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (client_)
     client_->DismissPictureBuffer(picture_buffer_id);
 }
 
 void GpuVideoDecodeAcceleratorHost::OnPictureReady(
     const AcceleratedVideoDecoderHostMsg_PictureReady_Params& params) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!client_)
     return;
   Picture picture(params.picture_buffer_id, params.bitstream_buffer_id,
@@ -271,19 +271,19 @@ void GpuVideoDecodeAcceleratorHost::OnPictureReady(
 }
 
 void GpuVideoDecodeAcceleratorHost::OnFlushDone() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (client_)
     client_->NotifyFlushDone();
 }
 
 void GpuVideoDecodeAcceleratorHost::OnResetDone() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (client_)
     client_->NotifyResetDone();
 }
 
 void GpuVideoDecodeAcceleratorHost::OnNotifyError(uint32_t error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!client_)
     return;
   weak_this_factory_.InvalidateWeakPtrs();

media/gpu/ipc/client/gpu_video_decode_accelerator_host.h

@@ -11,8 +11,8 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/non_thread_safe.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "ipc/ipc_listener.h"
 #include "media/video/video_decode_accelerator.h"
@@ -31,8 +31,7 @@ namespace media {
 class GpuVideoDecodeAcceleratorHost
     : public IPC::Listener,
       public VideoDecodeAccelerator,
-      public gpu::CommandBufferProxyImpl::DeletionObserver,
-      public base::NonThreadSafe {
+      public gpu::CommandBufferProxyImpl::DeletionObserver {
  public:
   // |this| is guaranteed not to outlive |impl|.  (See comments for |impl_|.)
   explicit GpuVideoDecodeAcceleratorHost(gpu::CommandBufferProxyImpl* impl);
@@ -106,6 +105,9 @@ class GpuVideoDecodeAcceleratorHost
 
   // WeakPtr for posting tasks to ourself.
   base::WeakPtr<GpuVideoDecodeAcceleratorHost> weak_this_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
   base::WeakPtrFactory<GpuVideoDecodeAcceleratorHost> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuVideoDecodeAcceleratorHost);

media/gpu/ipc/client/gpu_video_encode_accelerator_host.cc

@@ -30,7 +30,7 @@ GpuVideoEncodeAcceleratorHost::GpuVideoEncodeAcceleratorHost(
 }
 
 GpuVideoEncodeAcceleratorHost::~GpuVideoEncodeAcceleratorHost() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (channel_ && encoder_route_id_ != MSG_ROUTING_NONE)
     channel_->RemoveRoute(encoder_route_id_);
 
@@ -60,7 +60,7 @@ bool GpuVideoEncodeAcceleratorHost::OnMessageReceived(
 }
 
 void GpuVideoEncodeAcceleratorHost::OnChannelError() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (channel_) {
     if (encoder_route_id_ != MSG_ROUTING_NONE)
       channel_->RemoveRoute(encoder_route_id_);
@@ -71,7 +71,7 @@ void GpuVideoEncodeAcceleratorHost::OnChannelError() {
 
 VideoEncodeAccelerator::SupportedProfiles
 GpuVideoEncodeAcceleratorHost::GetSupportedProfiles() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return VideoEncodeAccelerator::SupportedProfiles();
   return GpuVideoAcceleratorUtil::ConvertGpuToMediaEncodeProfiles(
@@ -84,7 +84,7 @@ bool GpuVideoEncodeAcceleratorHost::Initialize(
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   client_ = client;
 
   base::AutoLock lock(impl_lock_);
@@ -117,7 +117,7 @@ bool GpuVideoEncodeAcceleratorHost::Initialize(
 void GpuVideoEncodeAcceleratorHost::Encode(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(PIXEL_FORMAT_I420, frame->format());
   DCHECK_EQ(VideoFrame::STORAGE_SHMEM, frame->storage_type());
   if (!channel_)
@@ -141,7 +141,7 @@ void GpuVideoEncodeAcceleratorHost::Encode(
 
 void GpuVideoEncodeAcceleratorHost::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
 
@@ -162,7 +162,7 @@ void GpuVideoEncodeAcceleratorHost::UseOutputBitstreamBuffer(
 void GpuVideoEncodeAcceleratorHost::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!channel_)
     return;
 
@@ -171,7 +171,7 @@ void GpuVideoEncodeAcceleratorHost::RequestEncodingParametersChange(
 }
 
 void GpuVideoEncodeAcceleratorHost::Destroy() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (channel_)
     Send(new AcceleratedVideoEncoderMsg_Destroy(encoder_route_id_));
   client_ = nullptr;
@@ -222,7 +222,7 @@ void GpuVideoEncodeAcceleratorHost::PostNotifyError(
     const tracked_objects::Location& location,
     Error error,
     const std::string& message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DLOG(ERROR) << "Error from " << location.function_name() << "("
               << location.file_name() << ":" << location.line_number() << ") "
               << message << " (error = " << error << ")";
@@ -233,7 +233,7 @@ void GpuVideoEncodeAcceleratorHost::PostNotifyError(
 }
 
 void GpuVideoEncodeAcceleratorHost::Send(IPC::Message* message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   uint32_t message_type = message->type();
   if (!channel_->Send(message)) {
     PostNotifyError(FROM_HERE, kPlatformFailureError,
@@ -245,7 +245,7 @@ void GpuVideoEncodeAcceleratorHost::OnRequireBitstreamBuffers(
     uint32_t input_count,
     const gfx::Size& input_coded_size,
     uint32_t output_buffer_size) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << __func__ << " input_count=" << input_count
            << ", input_coded_size=" << input_coded_size.ToString()
            << ", output_buffer_size=" << output_buffer_size;
@@ -256,7 +256,7 @@ void GpuVideoEncodeAcceleratorHost::OnRequireBitstreamBuffers(
 }
 
 void GpuVideoEncodeAcceleratorHost::OnNotifyInputDone(int32_t frame_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << __func__ << " frame_id=" << frame_id;
   // Fun-fact: std::hash_map is not spec'd to be re-entrant; since freeing a
   // frame can trigger a further encode to be kicked off and thus an .insert()
@@ -280,7 +280,7 @@ void GpuVideoEncodeAcceleratorHost::OnBitstreamBufferReady(
     uint32_t payload_size,
     bool key_frame,
     base::TimeDelta timestamp) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << __func__ << " bitstream_buffer_id=" << bitstream_buffer_id
            << ", payload_size=" << payload_size << ", key_frame=" << key_frame;
   if (client_)
@@ -289,7 +289,7 @@ void GpuVideoEncodeAcceleratorHost::OnBitstreamBufferReady(
 }
 
 void GpuVideoEncodeAcceleratorHost::OnNotifyError(Error error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DLOG(ERROR) << __func__ << " error=" << error;
   if (!client_)
     return;

media/gpu/ipc/client/gpu_video_encode_accelerator_host.h

@@ -13,8 +13,8 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
-#include "base/threading/non_thread_safe.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "ipc/ipc_listener.h"
@@ -43,8 +43,7 @@ namespace media {
 class GpuVideoEncodeAcceleratorHost
     : public IPC::Listener,
       public VideoEncodeAccelerator,
-      public gpu::CommandBufferProxyImpl::DeletionObserver,
-      public base::NonThreadSafe {
+      public gpu::CommandBufferProxyImpl::DeletionObserver {
  public:
   // |this| is guaranteed not to outlive |impl|.  (See comments for |impl_|.)
   explicit GpuVideoEncodeAcceleratorHost(gpu::CommandBufferProxyImpl* impl);
@@ -126,6 +125,8 @@ class GpuVideoEncodeAcceleratorHost
   // constructed.
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // WeakPtr factory for posting tasks back to itself.
   base::WeakPtrFactory<GpuVideoEncodeAcceleratorHost> weak_this_factory_;
 

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.cc

@@ -380,7 +380,7 @@ GpuJpegDecodeAccelerator::GpuJpegDecodeAccelerator(
       client_number_(0) {}
 
 GpuJpegDecodeAccelerator::~GpuJpegDecodeAccelerator() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (filter_) {
     channel_->RemoveFilter(filter_.get());
   }
@@ -388,7 +388,7 @@ GpuJpegDecodeAccelerator::~GpuJpegDecodeAccelerator() {
 
 void GpuJpegDecodeAccelerator::AddClient(int32_t route_id,
                                          base::Callback<void(bool)> response) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // When adding non-chromeos platforms, VideoCaptureGpuJpegDecoder::Initialize
   // needs to be updated.
@@ -435,12 +435,12 @@ void GpuJpegDecodeAccelerator::NotifyDecodeStatus(
     int32_t route_id,
     int32_t buffer_id,
     JpegDecodeAccelerator::Error error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Send(new AcceleratedJpegDecoderHostMsg_DecodeAck(route_id, buffer_id, error));
 }
 
 void GpuJpegDecodeAccelerator::ClientRemoved() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_GT(client_number_, 0);
   client_number_--;
   if (client_number_ == 0) {
@@ -450,7 +450,7 @@ void GpuJpegDecodeAccelerator::ClientRemoved() {
 }
 
 bool GpuJpegDecodeAccelerator::Send(IPC::Message* message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return channel_->Send(message);
 }
 

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h

@@ -12,8 +12,8 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/threading/non_thread_safe.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "media/video/jpeg_decode_accelerator.h"
@@ -43,7 +43,6 @@ class GpuJpegDecodeAcceleratorFactoryProvider {
 
 class GpuJpegDecodeAccelerator
     : public IPC::Sender,
-      public base::NonThreadSafe,
       public base::SupportsWeakPtr<GpuJpegDecodeAccelerator> {
  public:
   // |channel| must outlive this object.
@@ -94,6 +93,8 @@ class GpuJpegDecodeAccelerator
   // Number of clients added to |filter_|.
   int client_number_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(GpuJpegDecodeAccelerator);
 };
 

media/gpu/vaapi_picture.cc

@@ -31,7 +31,9 @@ VaapiPicture::VaapiPicture(
       client_texture_id_(client_texture_id),
       picture_buffer_id_(picture_buffer_id) {}
 
-VaapiPicture::~VaapiPicture() {}
+VaapiPicture::~VaapiPicture() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 // static
 linked_ptr<VaapiPicture> VaapiPicture::CreatePicture(

media/gpu/vaapi_picture.h

@@ -15,7 +15,7 @@
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/sequence_checker.h"
 #include "media/gpu/gpu_video_decode_accelerator_helpers.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
@@ -26,7 +26,7 @@ class VASurface;
 class VaapiWrapper;
 
 // Picture is native pixmap abstraction (X11/Ozone).
-class VaapiPicture : public base::NonThreadSafe {
+class VaapiPicture {
  public:
   // Create a VaapiPicture of |size| to be associated with |picture_buffer_id|.
   // If provided, bind it to |texture_id|, as well as to |client_texture_id|
@@ -87,6 +87,8 @@ class VaapiPicture : public base::NonThreadSafe {
  private:
   int32_t picture_buffer_id_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(VaapiPicture);
 };