Introducing the basic functionality to the speech input experimental API.

chrome/browser/extensions/extension_speech_input_api.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 "chrome/browser/extensions/extension_speech_input_api.h"
 
 #include "base/values.h"
+#include "chrome/browser/extensions/extension_speech_input_api_constants.h"
 #include "chrome/browser/extensions/extension_speech_input_manager.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
 
-SpeechInputAsyncFunction::SpeechInputAsyncFunction() {
+namespace constants = extension_speech_input_api_constants;
+
+SpeechInputAsyncFunction::SpeechInputAsyncFunction()
+    : failed_(false) {
 }
 
 void SpeechInputAsyncFunction::Run() {
+  ExtensionSpeechInputManager::State state =
+      ExtensionSpeechInputManager::GetForProfile(profile())->state();
 
-  // TODO(leandrogracia): implement the management of the asynchronous
-  // operations involved and the corresponding state transitions.
-  RunImpl();
+  if (failed_ || (state == StartState() && !RunImpl()))
+    SendResponse(false);
+
+  state = ExtensionSpeechInputManager::GetForProfile(profile())->state();
+
+  if (state == TransitionState()) {
+    registrar_.Add(this, TransitionNotification(),

[Satish, 2011/10/08 23:15:07]

when do you remove as a notification listener? should it be done in Observe
after you got the relevant notification or failure?

[Leandro Graciá Gil, 2011/10/09 10:29:21]

Removed on destruction with a flag to ensure we're listening (once).

On 2011/10/08 23:15:07, Satish wrote:

+        Source<const Extension>(GetExtension()));
+    AddRef(); // Balanced in Observe().
+    return;
+  }
+
+  if (state != EndState())
+    return;
 
   SendResponse(true);
 }
 
 void SpeechInputAsyncFunction::Observe(int type,
                                        const NotificationSource& source,
                                        const NotificationDetails& details) {
-  // TODO(leandrogracia): to be implemented.
+  DCHECK_EQ(GetExtension(), Source<const Extension>(source).ptr());
+  if (type == chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_FAILED)

[Satish, 2011/10/08 23:15:07]

suggest using braces for if-else blocks

[Leandro Graciá Gil, 2011/10/09 10:29:21]

Done.

+    failed_ = true;
+  else
+    DCHECK_EQ(type, TransitionNotification());
+
+  Run();

[Satish, 2011/10/08 23:15:07]

is there a possibility that in this call to Run() that the extension manager's
state is still the same as TransitionState() so we'll go in a loop here?

[Leandro Graciá Gil, 2011/10/09 10:29:21]

It should never be the case, as the transition notifications always come
together with state changes in the manager. In any case, I'm adding a flag to
ensure that we never try to register twice for listening.

On 2011/10/08 23:15:07, Satish wrote:

+  Release(); // Balanced in Run().
+}
+
+int StartSpeechInputFunction::StartState() {
+  return ExtensionSpeechInputManager::kIdle;
+}
+
+int StartSpeechInputFunction::TransitionState() {
+  return ExtensionSpeechInputManager::kStarting;
+}
+
+int StartSpeechInputFunction::EndState() {
+  return ExtensionSpeechInputManager::kRecording;
+}
+
+int StartSpeechInputFunction::TransitionNotification() {
+  return chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_STARTED;
 }
 
 bool StartSpeechInputFunction::RunImpl() {
-  ExtensionSpeechInputManager::GetForProfile(profile())->Start(GetExtension());
+  std::string language = constants::kDefaultLanguage;
+  std::string grammar = constants::kDefaultGrammar;
+  bool filter_profanities = constants::kDefaultFilterProfanities;
+
+  if (!args_->empty()) {
+    DictionaryValue *options;
+    if (!args_->GetDictionary(0, &options))
+      return false;

[Satish, 2011/10/08 23:15:07]

DCHECK(options) after this

[Leandro Graciá Gil, 2011/10/09 10:29:21]

Done.

+
+    if (options->HasKey(constants::kLanguageKey))
+      options->GetString(constants::kLanguageKey, &language);

[Satish, 2011/10/08 23:15:07]

should you check the return value of these calls?

[Leandro Graciá Gil, 2011/10/09 10:29:21]

The intention is that if they fail the variables will keep their default values.

On 2011/10/08 23:15:07, Satish wrote:

+    if (options->HasKey(constants::kGrammarKey))
+      options->GetString(constants::kGrammarKey, &grammar);
+
+    if (options->HasKey(constants::kFilterProfanitiesKey)) {
+      options->GetBoolean(constants::kFilterProfanitiesKey,
+          &filter_profanities);
+    }
+  }
+
+  ExtensionSpeechInputManager::GetForProfile(profile())->Start(
+      extension_id(), language, grammar, filter_profanities);
   return true;
 }
 
+int StopSpeechInputFunction::StartState() {
+  return ExtensionSpeechInputManager::kRecording;
+}
+
+int StopSpeechInputFunction::TransitionState() {
+  return ExtensionSpeechInputManager::kStopping;
+}
+
+int StopSpeechInputFunction::EndState() {
+  return ExtensionSpeechInputManager::kIdle;
+}
+
+int StopSpeechInputFunction::TransitionNotification() {
+  return chrome::NOTIFICATION_EXTENSION_SPEECH_INPUT_STOPPED;
+}
+
 bool StopSpeechInputFunction::RunImpl() {
-  ExtensionSpeechInputManager::GetForProfile(profile())->Stop(GetExtension());
+  ExtensionSpeechInputManager::GetForProfile(profile())->Stop(extension_id());
   return true;
 }
 
 bool IsRecordingSpeechInputFunction::RunImpl() {
-  // TODO(leandrogracia): to be implemented.
-  result_.reset(Value::CreateBooleanValue(false));
+  switch (ExtensionSpeechInputManager::GetForProfile(profile())->state()) {

[Satish, 2011/10/08 23:15:07]

This only allows you to tell if another extension was using speech input. What
if a web page was using instead? Ideally this call should tell the state of
speech reco in Chrome, not just about extensions, so the caller can make a
decision on what to do with UI buttons and what not

[Leandro Graciá Gil, 2011/10/09 10:29:21]

Will take a look into this after the next patch to avoid delaying the iterative
process.

On 2011/10/08 23:15:07, Satish wrote:

+  case ExtensionSpeechInputManager::kIdle:

[Satish, 2011/10/08 23:15:07]

case statements indented to right by 2 spaces
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Loops_and_Swit...

[Leandro Graciá Gil, 2011/10/09 10:29:21]

Good to know. I completely missed that style point. Thanks.

On 2011/10/08 23:15:07, Satish wrote:

+  case ExtensionSpeechInputManager::kStarting:
+    result_.reset(Value::CreateBooleanValue(false));
+    break;
+
+  case ExtensionSpeechInputManager::kRecording:
+  case ExtensionSpeechInputManager::kStopping:
+    result_.reset(Value::CreateBooleanValue(true));
+    break;
+
+  default:
+    NOTREACHED();
+  }
+
   return true;
 }