Applying changes to the existing speech input code to support the extension API.

content/browser/speech/speech_recognition_request.cc

 // Copyright (c) 2011 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_request.h"
 
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 namespace {
 
 const char* const kDefaultSpeechRecognitionUrl =
     "https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium&";
+const char* const kStatusString = "status";
 const char* const kHypothesesString = "hypotheses";
 const char* const kUtteranceString = "utterance";
 const char* const kConfidenceString = "confidence";
 
 // TODO(satish): Remove this hardcoded value once the page is allowed to
 // set this via an attribute.
 const int kMaxResults = 6;
 
 bool ParseServerResponse(const std::string& response_body,
-                         speech_input::SpeechInputResultArray* result) {
+                         speech_input::SpeechInputResult* result) {
   if (response_body.empty()) {
     LOG(WARNING) << "ParseServerResponse: Response was empty.";
     return false;
   }
   DVLOG(1) << "ParseServerResponse: Parsing response " << response_body;
 
   // Parse the response, ignoring comments.
   std::string error_msg;
   scoped_ptr<Value> response_value(base::JSONReader::ReadAndReturnError(
       response_body, false, NULL, &error_msg));
   if (response_value == NULL) {
     LOG(WARNING) << "ParseServerResponse: JSONReader failed : " << error_msg;
     return false;
   }
 
   if (!response_value->IsType(Value::TYPE_DICTIONARY)) {
     VLOG(1) << "ParseServerResponse: Unexpected response type "
             << response_value->GetType();
     return false;
   }
   const DictionaryValue* response_object =
       static_cast<DictionaryValue*>(response_value.get());
 
-  // Get the hypotheses
+  // Get the status.
+  if (!response_object->HasKey(kStatusString)) {
+    VLOG(1) << "ParseServerResponse: cannot find " << kStatusString
+            << " in the response object.";
+    return false;
+  }
+
+  Value* status_value = NULL;
+  response_object->GetWithoutPathExpansion(kStatusString, &status_value);

[Satish, 2011/10/04 20:36:33]

since the 'path' here is the first parameter and it doesn't have any dots, can't
we use the simpler "->Get()" method here? We probably don't need the above check
as well and could just check the return value of ->Get() like we do for
kHypothesesString below.

I also wonder if we could use ->GetAsInteger directly here and check the return
value of that to simplify all of this. Could you check if that fails when the
value is not an integer?

[Leandro Graciá Gil, 2011/10/05 22:09:00]

I think you're getting it the other way around. GetWithoutPathExpansion is
internally simpler as it doesn't check for any dots as Get does. Check
base/values.cc.

GetAsInteger might be used directly, and it will use Get internally and return
false in case of failure. I'll be using it.

On 2011/10/04 20:36:33, Satish wrote:

+  DCHECK(status_value);
+
+  if (!status_value->IsType(Value::TYPE_INTEGER)) {
+    VLOG(1) << "ParseServerResponse: Unexpected response status type "
+            << status_value->GetType();

[Satish, 2011/10/04 20:36:33]

return false here?

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Done.

+  }
+
+  int status;
+  DCHECK(status_value->GetAsInteger(&status));
+
+  // Process the status.
+  switch (status) {
+  case speech_input::kStatusSuccess:
+  case speech_input::kStatusNoSpeech:
+  case speech_input::kStatusNoMatch:
+    break;
+
+  default:
+    // Other status codes should not be returned by the server.
+    VLOG(1) << "ParseServerResponse: unexpected status code " << status;
+    return false;
+  }
+
+  result->status = static_cast<speech_input::SpeechInputResultStatus>(status);
+
+  // Get the hypotheses.
   Value* hypotheses_value = NULL;
   if (!response_object->Get(kHypothesesString, &hypotheses_value)) {
     VLOG(1) << "ParseServerResponse: Missing hypotheses attribute.";
     return false;
   }
+
   DCHECK(hypotheses_value);
   if (!hypotheses_value->IsType(Value::TYPE_LIST)) {
     VLOG(1) << "ParseServerResponse: Unexpected hypotheses type "
             << hypotheses_value->GetType();
     return false;
   }
+
   const ListValue* hypotheses_list = static_cast<ListValue*>(hypotheses_value);
 
   size_t index = 0;
   for (; index < hypotheses_list->GetSize(); ++index) {
     Value* hypothesis = NULL;
     if (!hypotheses_list->Get(index, &hypothesis)) {
       LOG(WARNING) << "ParseServerResponse: Unable to read hypothesis value.";
       break;
     }
     DCHECK(hypothesis);
     if (!hypothesis->IsType(Value::TYPE_DICTIONARY)) {
       LOG(WARNING) << "ParseServerResponse: Unexpected value type "
                    << hypothesis->GetType();
       break;
     }
 
     const DictionaryValue* hypothesis_value =
         static_cast<DictionaryValue*>(hypothesis);
     string16 utterance;
     if (!hypothesis_value->GetString(kUtteranceString, &utterance)) {
       LOG(WARNING) << "ParseServerResponse: Missing utterance value.";
       break;
     }
 
     // It is not an error if the 'confidence' field is missing.
     double confidence = 0.0;
     hypothesis_value->GetDouble(kConfidenceString, &confidence);
 
-    result->push_back(speech_input::SpeechInputResultItem(utterance,
-                                                          confidence));
+    result->hypotheses.push_back(speech_input::SpeechInputResultItem(
+        utterance, confidence));
   }
 
   if (index < hypotheses_list->GetSize()) {
-    result->clear();
+    result->hypotheses.clear();
+    result->status = speech_input::kStatusAborted;

[Satish, 2011/10/04 20:36:33]

is kStatusAborted the right error code? seems like it should be something like
'protocol error'

[Leandro Graciá Gil, 2011/10/05 22:09:00]

Changed to network error since it seems the closest option for the status value
(which is following this:
http://www.w3.org/2005/Incubator/htmlspeech/2010/10/google-api-draft.html#spe...
)

On 2011/10/04 20:36:33, Satish wrote:

     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace speech_input {
 
@@ skipping 66 matching lines @@
   DCHECK(url_fetcher_.get());
   url_fetcher_->AppendChunkToUpload(audio_data, is_last_chunk);
 }
 
 void SpeechRecognitionRequest::OnURLFetchComplete(const URLFetcher* source) {
   DCHECK_EQ(url_fetcher_.get(), source);
 
   bool error =
       !source->status().is_success() || source->response_code() != 200;
 
-  SpeechInputResultArray result;
+  SpeechInputResult result;
   if (!error)
     error = !ParseServerResponse(source->GetResponseStringRef(), &result);
   url_fetcher_.reset();
 
   DVLOG(1) << "SpeechRecognitionRequest: Invoking delegate with result.";
   delegate_->SetRecognitionResult(error, result);
 }
 
 }  // namespace speech_input