Introducing the basic functionality to the speech input experimental API.

chrome/browser/extensions/extension_speech_input_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SPEECH_INPUT_MANAGER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SPEECH_INPUT_MANAGER_H_
 #pragma once
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
+#include "base/synchronization/lock.h"
+#include "content/browser/speech/speech_recognizer.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
+#include "content/common/speech_input_result.h"
 #include <string>
 
 class Extension;
 class NotificationDetails;
 class NotificationSource;
 class Profile;
 
+namespace net {
+class URLRequestContextGetter;
+}
+
 // Manages the speech input requests and responses from the extensions
 // associated to the given profile.
 class ExtensionSpeechInputManager : public NotificationObserver,
-    public base::RefCountedThreadSafe<ExtensionSpeechInputManager> {
+    public base::RefCountedThreadSafe<ExtensionSpeechInputManager>,
+    public speech_input::SpeechRecognizerDelegate {
  public:
+  enum State {
+    kIdle = 0,
+    kStarting,
+    kRecording,
+    kStopping,
+    kShutdown // Internal sink state when the profile is destroyed on shutdown.
+  };
+
   // Should not be used directly. Managed by a ProfileKeyedServiceFactory.
-  explicit ExtensionSpeechInputManager(Profile* profile);
+  ExtensionSpeechInputManager(Profile* profile, int speech_caller_id);
 
   // Returns the corresponding manager for the given profile, creating
   // a new one if required.
   static ExtensionSpeechInputManager* GetForProfile(Profile* profile);
 
   // Initialize the ProfileKeyedServiceFactory.
   static void InitializeFactory();
 
+  // Request to start speech recognition for the provided extension.
+  void Start(const std::string& extension_id,
+             const std::string& language,
+             const std::string& grammar,
+             bool filter_profanities);
+
+  // Request to stop an ongoing speech recognition.
+  void Stop(const std::string& extension_id);
+
+  // Retrieve the actual state of the API manager.
+  State state() const { return state_; }
+
+  // Called by internal ProfileKeyedService class.
+  void ShutdownOnUIThread();
+
   // Methods from NotificationObserver.
   virtual void Observe(int type,
                        const NotificationSource& source,
-                       const NotificationDetails& details);
+                       const NotificationDetails& details) OVERRIDE;
 
-  // Request to start speech recognition for the provided extension.
-  void Start(const Extension *extension);
+  // Methods from SpeechRecognizerDelegate.
+  virtual void SetRecognitionResult(
+      int caller_id,
+      const speech_input::SpeechInputResult& result) OVERRIDE;
 
-  // Request to stop an ongoing speech recognition.
-  void Stop(const Extension *extension);
-
-  // Called by internal ProfileKeyedService class.
-  void ShutdownOnUIThread();
+  virtual void DidStartReceivingAudio(int caller_id) OVERRIDE;
+  virtual void DidCompleteRecording(int caller_id) OVERRIDE;
+  virtual void DidCompleteRecognition(int caller_id) OVERRIDE;
+  virtual void DidStartReceivingSpeech(int caller_id) OVERRIDE;
+  virtual void DidStopReceivingSpeech(int caller_id) OVERRIDE;
+  virtual void OnRecognizerError(int caller_id,
+                                 speech_input::SpeechInputError error)
+                                 OVERRIDE;
+  virtual void DidCompleteEnvironmentEstimation(int caller_id) OVERRIDE;
+  virtual void SetInputVolume(int caller_id, float volume,
+                              float noise_volume) OVERRIDE {}
 
  private:
+  void StartOnIOThread(
+      net::URLRequestContextGetter* context_getter,
+      const std::string& language,
+      const std::string& grammar,
+      bool filter_profanities);
+
+  void ForceStopOnIOThread();
+
+  void SetRecognitionResultOnUIThread(
+      const speech_input::SpeechInputResult& result);
+
+  void DidStartReceivingAudioOnUIThread();
+  void DispatchError(const std::string& code);
+
+  void DispatchEventToExtension(const std::string& event,
+                                const std::string& json_args);
   void ExtensionUnloaded(const std::string& id);
 
+  bool ShuttingDown();
+
+  virtual ~ExtensionSpeechInputManager();
+
   friend class base::RefCountedThreadSafe<ExtensionSpeechInputManager>;
   class Factory;
 
-  virtual ~ExtensionSpeechInputManager();
+  Profile* profile_;
+  std::string extension_id_;
+  NotificationRegistrar registrar_;
 
-  Profile* profile_;
-  scoped_refptr<Extension> extension_;
-  NotificationRegistrar registrar_;
+  int speech_caller_id_;
+  base::Lock state_lock_;

[Satish, 2011/10/09 20:01:47]

since you have a lock only for accessing/modifying the state_ variable, can you
comment here why this is the case? It would also be useful to separate out the
list of member vars based on which threads they are used in and comment on that
so it is clear to readers

[Leandro Graciá Gil, 2011/10/10 18:59:38]

Done.

+  State state_;
+  scoped_refptr<speech_input::SpeechRecognizer> recognizer_;
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SPEECH_INPUT_MANAGER_H_