Deprecate NonThreadSafe in content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h in …

content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.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 "content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 18 matching lines @@
     DecodeDoneCB decode_done_cb,
     base::Callback<void(const std::string&)> send_log_message_cb)
     : decode_done_cb_(std::move(decode_done_cb)),
       send_log_message_cb_(std::move(send_log_message_cb)),
       has_received_decoded_frame_(false),
       next_bitstream_buffer_id_(0),
       in_buffer_id_(media::JpegDecodeAccelerator::kInvalidBitstreamBufferId),
       decoder_status_(INIT_PENDING) {}
 
 VideoCaptureGpuJpegDecoder::~VideoCaptureGpuJpegDecoder() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // |decoder_| guarantees no more JpegDecodeAccelerator::Client callbacks
   // on IO thread after deletion.
   decoder_.reset();
 
   // |gpu_channel_host_| should outlive |decoder_|, so |gpu_channel_host_|
   // must be released after |decoder_| has been destroyed.
   gpu_channel_host_ = nullptr;
 }
 
 void VideoCaptureGpuJpegDecoder::Initialize() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::AutoLock lock(lock_);
   bool is_platform_supported =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeJpegDecodeAccelerator);
 #if defined(OS_CHROMEOS)
   // Non-ChromeOS platforms do not support HW JPEG decode now. Do not establish
   // gpu channel to avoid introducing overhead.
   is_platform_supported = true;
 #endif
 
   if (!is_platform_supported ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableAcceleratedMjpegDecode)) {
     decoder_status_ = FAILED;
     RecordInitDecodeUMA_Locked();
     return;
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> current_task_runner(
       base::ThreadTaskRunnerHandle::Get());
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&EstablishGpuChannelOnUIThread,
                                      current_task_runner, AsWeakPtr()));
 }
 
 VideoCaptureGpuJpegDecoder::STATUS VideoCaptureGpuJpegDecoder::GetStatus()
     const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::AutoLock lock(lock_);
   return decoder_status_;
 }
 
 void VideoCaptureGpuJpegDecoder::DecodeCapturedData(
     const uint8_t* data,
     size_t in_buffer_size,
     const media::VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     media::VideoCaptureDevice::Client::Buffer out_buffer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(decoder_);
 
   TRACE_EVENT_ASYNC_BEGIN0("jpeg", "VideoCaptureGpuJpegDecoder decoding",
                            next_bitstream_buffer_id_);
   TRACE_EVENT0("jpeg", "VideoCaptureGpuJpegDecoder::DecodeCapturedData");
 
   // TODO(kcwu): enqueue decode requests in case decoding is not fast enough
   // (say, if decoding time is longer than 16ms for 60fps 4k image)
   {
     base::AutoLock lock(lock_);
@@ skipping 133 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   task_runner->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureGpuJpegDecoder::FinishInitialization,
                             weak_this, std::move(gpu_channel_host)));
 }
 
 void VideoCaptureGpuJpegDecoder::FinishInitialization(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
   TRACE_EVENT0("gpu", "VideoCaptureGpuJpegDecoder::FinishInitialization");
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::AutoLock lock(lock_);
   if (!gpu_channel_host) {
     LOG(ERROR) << "Failed to establish GPU channel for JPEG decoder";
   } else if (gpu_channel_host->gpu_info().jpeg_decode_accelerator_supported) {
     gpu_channel_host_ = std::move(gpu_channel_host);
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
         BrowserGpuChannelHostFactory::instance()->GetIOThreadTaskRunner();
 
     int32_t route_id = gpu_channel_host_->GenerateRouteID();
     std::unique_ptr<media::GpuJpegDecodeAcceleratorHost> decoder(
@@ skipping 15 matching lines @@
   lock_.AssertAcquired();
   return !decode_done_closure_.is_null();
 }
 
 void VideoCaptureGpuJpegDecoder::RecordInitDecodeUMA_Locked() {
   UMA_HISTOGRAM_BOOLEAN("Media.VideoCaptureGpuJpegDecoder.InitDecodeSuccess",
                         decoder_status_ == INIT_PASSED);
 }
 
 }  // namespace content