Prototype of chunked transfer encoded POST.

chrome/browser/speech/speech_recognizer.cc

 // Copyright (c) 2010 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 "chrome/browser/speech/speech_recognizer.h"
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 123 matching lines @@
   // |StopRecording| being called.
   DCHECK(!audio_controller_.get());
   DCHECK(!request_.get() || !request_->HasPendingRequest());
   DCHECK(audio_buffers_.empty());
   endpointer_.EndSession();
 }
 
 bool SpeechRecognizer::StartRecording() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!audio_controller_.get());
-  DCHECK(!request_.get() || !request_->HasPendingRequest());
+  DCHECK(!request_.get());  // || !request_->HasPendingRequest());
 
   // The endpointer needs to estimate the environment/background noise before
   // starting to treat the audio as user input. In |HandleOnData| we wait until
   // such time has passed before switching to user input mode.
   endpointer_.SetEnvironmentEstimationMode();
 
   int samples_per_packet = (kAudioSampleRate * kAudioPacketIntervalMs) / 1000;
   DCHECK((samples_per_packet % encoder_->samples_per_frame()) == 0);
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kNumAudioChannels,
                          kAudioSampleRate, kNumBitsPerAudioSample,
                          samples_per_packet);
   audio_controller_ = AudioInputController::Create(this, params);
   DCHECK(audio_controller_.get());
   VLOG(1) << "SpeechRecognizer starting record.";
   num_samples_recorded_ = 0;
   audio_controller_->Record();
 
+  request_.reset(new SpeechRecognitionRequest(
+      Profile::GetDefaultRequestContext(), this));
+  request_->Start(language_, grammar_, hardware_info_, kContentTypeSpeex);
+
   return true;
 }
 
 void SpeechRecognizer::CancelRecognition() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(audio_controller_.get() || request_.get());
 
   // Stop recording if required.
   if (audio_controller_.get()) {
     VLOG(1) << "SpeechRecognizer stopping record.";
@@ skipping 12 matching lines @@
   // If audio recording has already stopped and we are in recognition phase,
   // silently ignore any more calls to stop recording.
   if (!audio_controller_.get())
     return;
 
   VLOG(1) << "SpeechRecognizer stopping record.";
   audio_controller_->Close();
   audio_controller_ = NULL;  // Releases the ref ptr.
 
   delegate_->DidCompleteRecording(caller_id_);
-
+  DCHECK(request_.get());
+  request_->FinishAudioUpload();
+/*
   // If we haven't got any audio yet end the recognition sequence here.
   if (audio_buffers_.empty()) {
     // Guard against the delegate freeing us until we finish our job.
     scoped_refptr<SpeechRecognizer> me(this);
     delegate_->DidCompleteRecognition(caller_id_);
     return;
   }
 
   // We now have recorded audio in our buffers, so start a recognition request.
   // Since the http request takes a single string as POST data, allocate
   // one and copy over bytes from the audio buffers to the string.
   int audio_buffer_length = 0;
   for (AudioBufferQueue::iterator it = audio_buffers_.begin();
        it != audio_buffers_.end(); it++) {
     audio_buffer_length += (*it)->length();
   }
   string data;
   data.reserve(audio_buffer_length);
   for (AudioBufferQueue::iterator it = audio_buffers_.begin();
        it != audio_buffers_.end(); it++) {
     data.append(*(*it));
   }
 
-  DCHECK(!request_.get());
-  request_.reset(new SpeechRecognitionRequest(
-      Profile::GetDefaultRequestContext(), this));
-  request_->Send(language_, grammar_, hardware_info_, kContentTypeSpeex, data);
   ReleaseAudioBuffers();  // No need to keep the audio anymore.
+*/
 }
 
 void SpeechRecognizer::ReleaseAudioBuffers() {
   for (AudioBufferQueue::iterator it = audio_buffers_.begin();
        it != audio_buffers_.end(); it++)
     delete *it;
   audio_buffers_.clear();
 }
 
 // Invoked in the audio thread.
@@ skipping 41 matching lines @@
   const short* samples = reinterpret_cast<const short*>(data->data());
   DCHECK((data->length() % sizeof(short)) == 0);
   int num_samples = data->length() / sizeof(short);
 
   encoder_->Encode(samples, num_samples, &audio_buffers_);
   float rms;
   endpointer_.ProcessAudio(samples, num_samples, &rms);
   delete data;
   num_samples_recorded_ += num_samples;
 
+  DCHECK(request_.get());
+  request_->UploadAudioChunk(**audio_buffers_.begin());
+  ReleaseAudioBuffers();
+
   if (endpointer_.IsEstimatingEnvironment()) {
     // Check if we have gathered enough audio for the endpointer to do
     // environment estimation and should move on to detect speech/end of speech.
     if (num_samples_recorded_ >= (kEndpointerEstimationTimeMs *
                                   kAudioSampleRate) / 1000) {
       endpointer_.SetUserInputMode();
       delegate_->DidCompleteEnvironmentEstimation(caller_id_);
     }
     return;  // No more processing since we are still estimating environment.
   }
@@ skipping 40 matching lines @@
 
 void SpeechRecognizer::InformErrorAndCancelRecognition(ErrorCode error) {
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
   scoped_refptr<SpeechRecognizer> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
 }  // namespace speech_input