Speech refactoring: Reimplemented SpeechRecognitionManagerImpl as a FSM. (CL1.7)

content/browser/speech/google_one_shot_remote_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/google_one_shot_remote_engine.h"
 
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/string_number_conversions.h"
@@ skipping 148 matching lines @@
 GoogleOneShotRemoteEngineConfig::GoogleOneShotRemoteEngineConfig()
     : filter_profanities(false),
       audio_sample_rate(kDefaultConfigSampleRate),
       audio_num_bits_per_sample(kDefaultConfigBitsPerSample) {
 }
 
 GoogleOneShotRemoteEngineConfig::~GoogleOneShotRemoteEngineConfig() {}
 
 GoogleOneShotRemoteEngine::GoogleOneShotRemoteEngine(
     net::URLRequestContextGetter* context)
-    : url_context_(context) {
+    : url_context_(context),
+      url_fetcher_destroyed_(false) {
 }
 
 GoogleOneShotRemoteEngine::~GoogleOneShotRemoteEngine() {}
 
 void GoogleOneShotRemoteEngine::SetConfig(
     const GoogleOneShotRemoteEngineConfig& config) {
   config_ = config;
 }
 
 void GoogleOneShotRemoteEngine::StartRecognition() {
   DCHECK(delegate());
-  DCHECK(!url_fetcher_.get());
+  DCHECK(!url_fetcher_.get() || url_fetcher_destroyed_);
   std::string lang_param = config_.language;
 
   if (lang_param.empty() && url_context_) {
     // If no language is provided then we use the first from the accepted
     // language list. If this list is empty then it defaults to "en-US".
     // Example of the contents of this list: "es,en-GB;q=0.8", ""
     net::URLRequestContext* request_context =
         url_context_->GetURLRequestContext();
     DCHECK(request_context);
     std::string accepted_language_list = request_context->accept_language();
@@ skipping 30 matching lines @@
   url_fetcher_->SetRequestContext(url_context_);
   url_fetcher_->SetReferrer(config_.origin_url);
 
   // The speech recognition API does not require user identification as part
   // of requests, so we don't send cookies or auth data for these requests to
   // prevent any accidental connection between users who are logged into the
   // domain for other services (e.g. bookmark sync) with the speech requests.
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                              net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SEND_AUTH_DATA);
+  url_fetcher_destroyed_ = false;
   url_fetcher_->Start();
 }
 
 void GoogleOneShotRemoteEngine::EndRecognition() {
-  url_fetcher_.reset();
+  // TODO(primiano) URLFetcher(Core) seems to be currently broken. In particular
+  // I am experiencing a failure in the case of a recognition suddenly aborted,
+  // with a DCHECK in content::URLFetcherCore::CompleteAddingUploadDataChunk().
+  // What happens is that this method (thus the url_fetcher dtor) might be
+  // called immediately after an AppendChunkToUpload. AppendChunkToUpload is
+  // not executed synchronously (inside URLFetcher) but defers its work to a
+  // posted task. However, it seems to me that the posted routine
+  // (CompleteAddingUploadDataChunk) does not take into account the corner case
+  // in which the URLFetcher is destructed in the meanwhile (which in turn
+  // causes a Stop() call on URLFetcherCore)
+  // Therefore I am currently commenting the .reset() call and adding the
+  // url_fetcher_destroyed_ workaround (read hack). This should not cause any
+  // memory leak due to the scoped_ptr smart pointer.
+
+  // url_fetcher_.reset();
+  url_fetcher_destroyed_ = true;
 }
 
 void GoogleOneShotRemoteEngine::TakeAudioChunk(const AudioChunk& data) {
-  DCHECK(url_fetcher_.get());
+  DCHECK(url_fetcher_.get() && !url_fetcher_destroyed_);
   DCHECK(encoder_.get());
   DCHECK_EQ(data.bytes_per_sample(), config_.audio_num_bits_per_sample / 8);
   encoder_->Encode(data);
   scoped_refptr<AudioChunk> encoded_data(encoder_->GetEncodedDataAndClear());
   url_fetcher_->AppendChunkToUpload(encoded_data->AsString(), false);
 }
 
 void GoogleOneShotRemoteEngine::AudioChunksEnded() {
-  DCHECK(url_fetcher_.get());
+  DCHECK(url_fetcher_.get() && !url_fetcher_destroyed_);
   DCHECK(encoder_.get());
 
   // UploadAudioChunk requires a non-empty final buffer. So we encode a packet
   // of silence in case encoder had no data already.
   std::vector<int16> samples(
       config_.audio_sample_rate * kAudioPacketIntervalMs / 1000);
   scoped_refptr<AudioChunk> dummy_chunk(
       new AudioChunk(reinterpret_cast<uint8*>(&samples[0]),
                      samples.size() * sizeof(int16),
                      encoder_->bits_per_sample() / 8));
   encoder_->Encode(*dummy_chunk);
   encoder_->Flush();
   scoped_refptr<AudioChunk> encoded_dummy_data(
       encoder_->GetEncodedDataAndClear());
   DCHECK(!encoded_dummy_data->IsEmpty());
   encoder_.reset();
 
   url_fetcher_->AppendChunkToUpload(encoded_dummy_data->AsString(), true);
 }
 
 void GoogleOneShotRemoteEngine::OnURLFetchComplete(
     const content::URLFetcher* source) {
+  if (url_fetcher_destroyed_)
+    return;
   DCHECK_EQ(url_fetcher_.get(), source);
   SpeechRecognitionResult result;
   SpeechRecognitionError error(content::SPEECH_RECOGNITION_ERROR_NETWORK);
   std::string data;
 
   // The default error code in case of parse errors is NETWORK_FAILURE, however
   // ParseServerResponse can change the error to a more appropriate one.
   bool error_occurred = (!source->GetStatus().is_success() ||
                         source->GetResponseCode() != 200 ||
                         !source->GetResponseAsString(&data) ||
                         !ParseServerResponse(data, &result, &error));
   url_fetcher_.reset();
   if (error_occurred) {
     DVLOG(1) << "GoogleOneShotRemoteEngine: Network Error " << error.code;
     delegate()->OnSpeechRecognitionEngineError(error);
   } else {
     DVLOG(1) << "GoogleOneShotRemoteEngine: Invoking delegate with result.";
     delegate()->OnSpeechRecognitionEngineResult(result);
   }
 }
 
 bool GoogleOneShotRemoteEngine::IsRecognitionPending() const {
-  return url_fetcher_ != NULL;
+  return url_fetcher_ != NULL && !url_fetcher_destroyed_;
 }
 
 int GoogleOneShotRemoteEngine::GetDesiredAudioChunkDurationMs() const {
   return kAudioPacketIntervalMs;
 }
 
 }  // namespace speech