RefCounted types should not have public destructors, content/browser part 1

content/browser/speech/speech_recognizer_impl.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_recognizer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 112 matching lines @@
   DCHECK(recognition_engine_ != NULL);
   endpointer_.set_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond / 2);
   endpointer_.set_long_speech_input_complete_silence_length(
       base::Time::kMicrosecondsPerSecond);
   endpointer_.set_long_speech_length(3 * base::Time::kMicrosecondsPerSecond);
   endpointer_.StartSession();
   recognition_engine_->set_delegate(this);
 }
 
-SpeechRecognizerImpl::~SpeechRecognizerImpl() {
-  endpointer_.EndSession();
-}
-
 // -------  Methods that trigger Finite State Machine (FSM) events ------------
 
 // NOTE:all the external events and requests should be enqueued (PostTask), even
 // if they come from the same (IO) thread, in order to preserve the relationship
 // of causality between events and avoid interleaved event processing due to
 // synchronous callbacks.
 
 void SpeechRecognizerImpl::StartRecognition() {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizerImpl::DispatchEvent,
@@ skipping 21 matching lines @@
 
 bool SpeechRecognizerImpl::IsCapturingAudio() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); // See IsActive().
   const bool is_capturing_audio = state_ >= STATE_STARTING &&
                                   state_ <= STATE_RECOGNIZING;
   DCHECK((is_capturing_audio && (audio_controller_.get() != NULL)) ||
          (!is_capturing_audio && audio_controller_.get() == NULL));
   return is_capturing_audio;
 }
 
+const SpeechRecognitionEngine&
+SpeechRecognizerImpl::recognition_engine() const {
+  return *(recognition_engine_.get());
+}
+
+SpeechRecognizerImpl::~SpeechRecognizerImpl() {
+  endpointer_.EndSession();
+}
+
 // Invoked in the audio thread.
 void SpeechRecognizerImpl::OnError(AudioInputController* controller,
                                    int error_code) {
   FSMEventArgs event_args(EVENT_AUDIO_ERROR);
   event_args.audio_error_code = error_code;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizerImpl::DispatchEvent,
                                      this, event_args));
 }
 
@@ skipping 427 matching lines @@
 
   float noise_level = (endpointer_.NoiseLevelDb() - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   noise_level = std::min(std::max(0.0f, noise_level),
                          kAudioMeterRangeMaxUnclipped);
 
   listener_->OnAudioLevelsChange(
       session_id_, clip_detected ? 1.0f : audio_level_, noise_level);
 }
 
-const SpeechRecognitionEngine&
-    SpeechRecognizerImpl::recognition_engine() const {
-  return *(recognition_engine_.get());
-}
-
 void SpeechRecognizerImpl::SetAudioManagerForTesting(
     AudioManager* audio_manager) {
   testing_audio_manager_ = audio_manager;
 }
 
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_error_code(0),
       audio_data(NULL),
       engine_error(content::SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace speech