Rename CalledOnValidSequencedThread() to CalledOnValidSequence().

media/gpu/media_foundation_video_encode_accelerator_win.cc

 // Copyright 2016 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/media_foundation_video_encode_accelerator_win.h"
 
 #pragma warning(push)
 #pragma warning(disable : 4800)  // Disable warning for added padding.
 
 #include <codecapi.h>
@@ skipping 64 matching lines @@
 };
 
 MediaFoundationVideoEncodeAccelerator::MediaFoundationVideoEncodeAccelerator()
     : client_task_runner_(base::SequencedTaskRunnerHandle::Get()),
       encoder_thread_("MFEncoderThread"),
       encoder_task_weak_factory_(this) {}
 
 MediaFoundationVideoEncodeAccelerator::
     ~MediaFoundationVideoEncodeAccelerator() {
   DVLOG(3) << __FUNCTION__;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles() {
   DVLOG(3) << __FUNCTION__;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   SupportedProfiles profiles;
   if (base::win::GetVersion() < base::win::VERSION_WIN8) {
     DLOG(ERROR) << "Windows versions earlier than 8 are not supported.";
     return profiles;
   }
 
   SupportedProfile profile;
   // More profiles can be supported here, but they should be available in SW
   // fallback as well.
   profile.profile = H264PROFILE_BASELINE;
   profile.max_framerate_numerator = kMaxFrameRateNumerator;
   profile.max_framerate_denominator = kMaxFrameRateDenominator;
   profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
   profiles.push_back(profile);
   return profiles;
 }
 
 bool MediaFoundationVideoEncodeAccelerator::Initialize(
     VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
   DVLOG(3) << __FUNCTION__
            << ": input_format=" << VideoPixelFormatToString(format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
                 << VideoPixelFormatToString(format);
     return false;
   }
 
   if (H264PROFILE_BASELINE != output_profile) {
     DLOG(ERROR) << "Output profile not supported= " << output_profile;
     return false;
@@ skipping 67 matching lines @@
       FROM_HERE,
       base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
                  input_visible_size_, bitstream_buffer_size_));
   return SUCCEEDED(hr);
 }
 
 void MediaFoundationVideoEncodeAccelerator::Encode(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << __FUNCTION__;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MediaFoundationVideoEncodeAccelerator::EncodeTask,
                             encoder_task_weak_factory_.GetWeakPtr(), frame,
                             force_keyframe));
 }
 
 void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const BitstreamBuffer& buffer) {
   DVLOG(3) << __FUNCTION__ << ": buffer size=" << buffer.size();
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (buffer.size() < bitstream_buffer_size_) {
     DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
                 << " vs. " << bitstream_buffer_size_;
     client_->NotifyError(kInvalidArgumentError);
     return;
   }
 
   std::unique_ptr<base::SharedMemory> shm(
       new base::SharedMemory(buffer.handle(), false));
@@ skipping 10 matching lines @@
       base::Bind(
           &MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
           encoder_task_weak_factory_.GetWeakPtr(), base::Passed(&buffer_ref)));
 }
 
 void MediaFoundationVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << __FUNCTION__ << ": bitrate=" << bitrate
            << ": framerate=" << framerate;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaFoundationVideoEncodeAccelerator::
                      RequestEncodingParametersChangeTask,
                  encoder_task_weak_factory_.GetWeakPtr(), bitrate, framerate));
 }
 
 void MediaFoundationVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << __FUNCTION__;
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // Cancel all callbacks.
   client_ptr_factory_.reset();
 
   if (encoder_thread_.IsRunning()) {
     encoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MediaFoundationVideoEncodeAccelerator::DestroyTask,
                    encoder_task_weak_factory_.GetWeakPtr()));
     encoder_thread_.Stop();
   }
 
   delete this;
 }
 
 // static
 void MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization() {
   for (const wchar_t* mfdll : kMediaFoundationVideoEncoderDLLs)
     ::LoadLibrary(mfdll);
 }
 
 bool MediaFoundationVideoEncodeAccelerator::InitializeInputOutputSamples() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   HRESULT hr = encoder_->GetStreamLimits(
       &input_stream_count_min_, &input_stream_count_max_,
       &output_stream_count_min_, &output_stream_count_max_);
   RETURN_ON_HR_FAILURE(hr, "Couldn't query stream limits", false);
   DVLOG(3) << "Stream limits: " << input_stream_count_min_ << ","
            << input_stream_count_max_ << "," << output_stream_count_min_ << ","
            << output_stream_count_max_;
 
   // Initialize output parameters.
@@ skipping 45 matching lines @@
 
   input_sample_.Attach(mf::CreateEmptySampleWithBuffer(
       VideoFrame::AllocationSize(PIXEL_FORMAT_I420, input_visible_size_), 2));
   output_sample_.Attach(mf::CreateEmptySampleWithBuffer(
       bitstream_buffer_size_ * kOutputSampleBufferSizeRatio, 2));
 
   return SUCCEEDED(hr);
 }
 
 bool MediaFoundationVideoEncodeAccelerator::SetEncoderModes() {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   HRESULT hr = encoder_.QueryInterface(IID_ICodecAPI, codec_api_.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "Couldn't get ICodecAPI", false);
   VARIANT var;
   var.vt = VT_UI4;
   var.ulVal = eAVEncCommonRateControlMode_CBR;
   hr = codec_api_->SetValue(&CODECAPI_AVEncCommonRateControlMode, &var);
   RETURN_ON_HR_FAILURE(hr, "Couldn't set CommonRateControlMode", false);
   var.ulVal = target_bitrate_;
   hr = codec_api_->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
@@ skipping 188 matching lines @@
   DVLOG(3) << __FUNCTION__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   // Cancel all encoder thread callbacks.
   encoder_task_weak_factory_.InvalidateWeakPtrs();
 
   encoder_.Release();
 }
 
 }  // namespace content