Replace deprecated base::NonThreadSafe in /content/browser/speech in favor of SequenceChecker.

content/browser/speech/speech_recognition_engine.cc

 // Copyright (c) 2012 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/speech/speech_recognition_engine.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/big_endian.h"
@@ skipping 84 matching lines @@
 
 SpeechRecognitionEngine::SpeechRecognitionEngine(
     net::URLRequestContextGetter* context)
     : url_context_(context),
       previous_response_length_(0),
       got_last_definitive_result_(false),
       is_dispatching_event_(false),
       use_framed_post_data_(false),
       state_(STATE_IDLE) {}
 
-SpeechRecognitionEngine::~SpeechRecognitionEngine() {}
+SpeechRecognitionEngine::~SpeechRecognitionEngine() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 void SpeechRecognitionEngine::SetConfig(const Config& config) {
   config_ = config;
 }
 
 void SpeechRecognitionEngine::StartRecognition() {
   FSMEventArgs event_args(EVENT_START_RECOGNITION);
   DispatchEvent(event_args);
 }
 
@@ skipping 22 matching lines @@
     const URLFetcher* source,
     int64_t current,
     int64_t total,
     int64_t current_network_bytes) {
   const bool kPartialResponse = false;
   DispatchHTTPResponse(source, kPartialResponse);
 }
 
 void SpeechRecognitionEngine::DispatchHTTPResponse(const URLFetcher* source,
                                                    bool end_of_response) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(source);
   const bool response_is_good = source->GetStatus().is_success() &&
                                 source->GetResponseCode() == 200;
   std::string response;
   if (response_is_good)
     source->GetResponseAsString(&response);
   const size_t current_response_length = response.size();
 
   DVLOG(1) << (source == downstream_fetcher_.get() ? "Downstream" : "Upstream")
            << "HTTP, code: " << source->GetResponseCode()
@@ skipping 48 matching lines @@
                              event_args.response->end()));
     DispatchEvent(event_args);
   }
   if (end_of_response) {
     FSMEventArgs event_args(EVENT_DOWNSTREAM_CLOSED);
     DispatchEvent(event_args);
   }
 }
 
 bool SpeechRecognitionEngine::IsRecognitionPending() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return state_ != STATE_IDLE;
 }
 
 int SpeechRecognitionEngine::GetDesiredAudioChunkDurationMs() const {
   return kAudioPacketIntervalMs;
 }
 
 // -----------------------  Core FSM implementation ---------------------------
 
 void SpeechRecognitionEngine::DispatchEvent(
     const FSMEventArgs& event_args) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_LE(event_args.event, EVENT_MAX_VALUE);
   DCHECK_LE(state_, STATE_MAX_VALUE);
 
   // Event dispatching must be sequential, otherwise it will break all the rules
   // and the assumptions of the finite state automata model.
   DCHECK(!is_dispatching_event_);
   is_dispatching_event_ = true;
 
   state_ = ExecuteTransitionAndGetNextState(event_args);
 
@@ skipping 482 matching lines @@
 }
 
 SpeechRecognitionEngine::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value) {
 }
 
 SpeechRecognitionEngine::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content