Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/speech/speech_recognizer_impl.cc

 // Copyright (c) 2013 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 133 matching lines @@
   return is_capturing_audio;
 }
 
 const SpeechRecognitionEngine&
 SpeechRecognizerImpl::recognition_engine() const {
   return *(recognition_engine_.get());
 }
 
 SpeechRecognizerImpl::~SpeechRecognizerImpl() {
   endpointer_.EndSession();
-  if (audio_controller_) {
-    audio_controller_->Close(base::Bind(&KeepAudioControllerRefcountedForDtor,
-                                        audio_controller_));
+  if (audio_controller_.get()) {
+    audio_controller_->Close(
+        base::Bind(&KeepAudioControllerRefcountedForDtor, audio_controller_));
   }
 }
 
 // Invoked in the audio thread.
 void SpeechRecognizerImpl::OnError(AudioInputController* controller) {
   FSMEventArgs event_args(EVENT_AUDIO_ERROR);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&SpeechRecognizerImpl::DispatchEvent,
                                      this, event_args));
 }
@@ skipping 51 matching lines @@
   // 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;
 
   // Guard against the delegate freeing us until we finish processing the event.
   scoped_refptr<SpeechRecognizerImpl> me(this);
 
   if (event_args.event == EVENT_AUDIO_DATA) {
     DCHECK(event_args.audio_data.get() != NULL);
-    ProcessAudioPipeline(*event_args.audio_data);
+    ProcessAudioPipeline(*event_args.audio_data.get());
   }
 
   // The audio pipeline must be processed before the event dispatch, otherwise
   // it would take actions according to the future state instead of the current.
   state_ = ExecuteTransitionAndGetNextState(event_args);
   is_dispatching_event_ = false;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::ExecuteTransitionAndGetNextState(
@@ skipping 193 matching lines @@
 SpeechRecognizerImpl::StartRecognitionEngine(const FSMEventArgs& event_args) {
   // This is the first audio packet captured, so the recognition engine is
   // started and the delegate notified about the event.
   DCHECK(recognition_engine_.get() != NULL);
   recognition_engine_->StartRecognition();
   listener_->OnAudioStart(session_id_);
 
   // This is a little hack, since TakeAudioChunk() is already called by
   // ProcessAudioPipeline(). It is the best tradeoff, unless we allow dropping
   // the first audio chunk captured after opening the audio device.
-  recognition_engine_->TakeAudioChunk(*(event_args.audio_data));
+  recognition_engine_->TakeAudioChunk(*(event_args.audio_data.get()));
   return STATE_ESTIMATING_ENVIRONMENT;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::WaitEnvironmentEstimationCompletion(const FSMEventArgs&) {
   DCHECK(endpointer_.IsEstimatingEnvironment());
   if (GetElapsedTimeMs() >= kEndpointerEstimationTimeMs) {
     endpointer_.SetUserInputMode();
     listener_->OnEnvironmentEstimationComplete(session_id_);
     return STATE_WAITING_FOR_SPEECH;
@@ skipping 206 matching lines @@
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_data(NULL),
       engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content