Fixed a memory leak in SpeechRecognitionManagerImpl causing ChromeSpeechInputManagerDelegate to be …

content/browser/speech/speech_recognition_manager_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_recognition_manager_impl.h"
 
 #include "base/bind.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/speech/input_tag_speech_dispatcher_host.h"
@@ skipping 55 matching lines @@
   content::SpeechRecognitionPreferences* recognition_prefs;
 };
 
 SpeechRecognitionManagerImpl* SpeechRecognitionManagerImpl::GetInstance() {
   return Singleton<SpeechRecognitionManagerImpl>::get();
 }
 
 SpeechRecognitionManagerImpl::SpeechRecognitionManagerImpl()
     : can_report_metrics_(false),
       recording_caller_id_(0) {
-  delegate_ = content::GetContentClient()->browser()->
-                  GetSpeechRecognitionManagerDelegate();
+  delegate_.reset(content::GetContentClient()->browser()->
+                  GetSpeechRecognitionManagerDelegate());
 }
 
 SpeechRecognitionManagerImpl::~SpeechRecognitionManagerImpl() {
   while (requests_.begin() != requests_.end())
     CancelRecognition(requests_.begin()->first);
 }
 
 bool SpeechRecognitionManagerImpl::HasAudioInputDevices() {
   return BrowserMainLoop::GetAudioManager()->HasAudioInputDevices();
 }
@@ skipping 77 matching lines @@
         base::Bind(&SpeechRecognitionManagerImpl::ProceedStartingRecognition,
         base::Unretained(this), params));
   }
 }
 
 void SpeechRecognitionManagerImpl::ProceedStartingRecognition(
     const SpeechRecognitionParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!HasPendingRequest(params.caller_id));
 
-  if (delegate_) {
+  if (delegate_ != NULL) {

[jam, 2012/04/13 18:19:54]

by convention we don't do if (foo != NULL), but just if (foo). in case of scoped
ptrs, if (foo.get())

[Primiano Tucci (use gerrit), 2012/04/16 08:47:37]

Ah, I am sorry, I was not aware. I fixed it.
Can I just ask the rationale behind this convention?
I opted for != NULL just because it would work keeping the same semantic
regardless the type of pointer (smart or not) being used.

     delegate_->ShowRecognitionRequested(
         params.caller_id, params.render_process_id, params.render_view_id,
         params.element_rect);
     delegate_->GetRequestInfo(&can_report_metrics_, &request_info_);
   }
 
   Request* request = &requests_[params.caller_id];
   request->delegate = params.delegate;
   request->recognizer = content::SpeechRecognizer::Create(
       this, params.caller_id, params.language, params.grammar,
@@ skipping 13 matching lines @@
 
   // We should not currently be recording for the caller.
   CHECK(recording_caller_id_ != caller_id);
 
   // If we are currently recording audio for another caller, abort that cleanly.
   if (recording_caller_id_)
     CancelRecognitionAndInformDelegate(recording_caller_id_);
   recording_caller_id_ = caller_id;
   requests_[caller_id].is_active = true;
   requests_[caller_id].recognizer->StartRecognition();
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->ShowWarmUp(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognitionForRequest(int caller_id) {
   // Ignore if the caller id was not in our active recognizers list because the
   // user might have clicked more than once, or recognition could have been
   // ended due to other reasons before the user click was processed.
   if (!HasPendingRequest(caller_id))
     return;
 
@@ skipping 13 matching lines @@
     CancelRecognitionAndInformDelegate(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognition(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   if (requests_[caller_id].is_active)
     requests_[caller_id].recognizer->AbortRecognition();
   requests_.erase(caller_id);
   if (recording_caller_id_ == caller_id)
     recording_caller_id_ = 0;
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->DoClose(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::CancelAllRequestsWithDelegate(
     InputTagSpeechDispatcherHost* delegate) {
   SpeechRecognizerMap::iterator it = requests_.begin();
   while (it != requests_.end()) {
     if (it->second.delegate == delegate) {
       CancelRecognition(it->first);
       // This map will have very few elements so it is simpler to restart.
@@ skipping 22 matching lines @@
 
 void SpeechRecognitionManagerImpl::OnAudioEnd(int caller_id) {
   if (recording_caller_id_ != caller_id)
     return;
   DCHECK_EQ(recording_caller_id_, caller_id);
   DCHECK(HasPendingRequest(caller_id));
   if (!requests_[caller_id].is_active)
     return;
   recording_caller_id_ = 0;
   GetDelegate(caller_id)->DidCompleteRecording(caller_id);
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->ShowRecognizing(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionEnd(int caller_id) {
   if (!HasPendingRequest(caller_id) || !requests_[caller_id].is_active)
     return;
   GetDelegate(caller_id)->DidCompleteRecognition(caller_id);
   requests_.erase(caller_id);
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->DoClose(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::OnSoundStart(int caller_id) {
 }
 
 void SpeechRecognitionManagerImpl::OnSoundEnd(int caller_id) {
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionError(
     int caller_id, const content::SpeechRecognitionError& error) {
   DCHECK(HasPendingRequest(caller_id));
   if (caller_id == recording_caller_id_)
     recording_caller_id_ = 0;
   requests_[caller_id].is_active = false;
-  if (delegate_) {
+  if (delegate_ != NULL) {
     if (error.code == content::SPEECH_RECOGNITION_ERROR_AUDIO &&
         error.details == content::SPEECH_AUDIO_ERROR_DETAILS_NO_MIC) {
       delegate_->ShowMicError(caller_id,
           SpeechRecognitionManagerDelegate::MIC_ERROR_NO_DEVICE_AVAILABLE);
     } else if (error.code == content::SPEECH_RECOGNITION_ERROR_AUDIO &&
                error.details == content::SPEECH_AUDIO_ERROR_DETAILS_IN_USE) {
       delegate_->ShowMicError(
           caller_id, SpeechRecognitionManagerDelegate::MIC_ERROR_DEVICE_IN_USE);
     } else {
       delegate_->ShowRecognizerError(caller_id, error.code);
     }
   }
 }
 
 void SpeechRecognitionManagerImpl::OnAudioStart(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK_EQ(recording_caller_id_, caller_id);
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->ShowRecording(caller_id);
 }
 
 void SpeechRecognitionManagerImpl::OnRecognitionStart(int caller_id) {
 }
 
 void SpeechRecognitionManagerImpl::OnEnvironmentEstimationComplete(
     int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK_EQ(recording_caller_id_, caller_id);
 }
 
 void SpeechRecognitionManagerImpl::OnAudioLevelsChange(
     int caller_id, float volume, float noise_volume) {
   DCHECK(HasPendingRequest(caller_id));
   DCHECK_EQ(recording_caller_id_, caller_id);
-  if (delegate_)
+  if (delegate_ != NULL)
     delegate_->ShowInputVolume(caller_id, volume, noise_volume);
 }
 
 void SpeechRecognitionManagerImpl::CancelRecognitionAndInformDelegate(
     int caller_id) {
   InputTagSpeechDispatcherHost* cur_delegate = GetDelegate(caller_id);
   CancelRecognition(caller_id);
   cur_delegate->DidCompleteRecording(caller_id);
   cur_delegate->DidCompleteRecognition(caller_id);
 }
 
 SpeechRecognitionManagerImpl::Request::Request()
-    : delegate(NULL),
-      is_active(false) {
+    : is_active(false) {
 }
 
 SpeechRecognitionManagerImpl::Request::~Request() {
 }
 
 }  // namespace speech