Make specch input extension api a PKS.

chrome/browser/speech/speech_input_extension_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_SPEECH_SPEECH_INPUT_EXTENSION_MANAGER_H_
 #define CHROME_BROWSER_SPEECH_SPEECH_INPUT_EXTENSION_MANAGER_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
+#include "chrome/browser/extensions/api/profile_keyed_api_factory.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/speech_recognition_event_listener.h"
 
 class Profile;
 
 namespace base {
 class ListValue;
 }
 
 namespace content {
@@ skipping 58 matching lines @@
 
   typedef base::Callback<void(bool)> IsRecordingCallback;
 
   // Should not be used directly. Managed by a ProfileKeyedServiceFactory.
   explicit SpeechInputExtensionManager(Profile* profile);
 
   // Returns the corresponding manager for the given profile, creating
   // a new one if required.
   static SpeechInputExtensionManager* GetForProfile(Profile* profile);
 
-  // Initialize the ProfileKeyedServiceFactory.
-  static void InitializeFactory();
-
   // Request to start speech recognition for the provided extension.
   bool Start(const std::string& extension_id,
              const std::string& language,
              const std::string& grammar,
              bool filter_profanities,
              std::string* error);
 
   // Request to stop an ongoing speech recognition.
   bool Stop(const std::string& extension_id, std::string* error);
 
@@ skipping 76 matching lines @@
 
   void ResetToIdleState();
 
   void AbortAllSessionsOnIOThread();
 
   int GetRenderProcessIDForExtension(const std::string& extension_id) const;
 
   virtual ~SpeechInputExtensionManager();
 
   friend class base::RefCountedThreadSafe<SpeechInputExtensionManager>;
-  class Factory;
 
   // Lock used to allow exclusive access to the state variable and methods that
   // either read or write on it. This is required since the speech code
   // operates in the IO thread while the extension code uses the UI thread.
   base::Lock state_lock_;
 
   // Used in the UI thread but also its raw value as notification
   // source in the IO thread, guarded by the state lock and value.
   Profile* profile_;
 
   // Used in both threads, guarded by the state lock.
   State state_;
   std::string extension_id_in_use_;
 
   // Used in the UI thread.
   scoped_ptr<content::NotificationRegistrar> registrar_;
   SpeechInputExtensionInterface* speech_interface_;
 
   // Used in the IO thread.
   bool is_recognition_in_progress_;
   int speech_recognition_session_id_;
 };
 
+namespace extensions {
+
+class SpeechInputAPI : public ProfileKeyedAPI {
+ public:
+  explicit SpeechInputAPI(Profile* profile);
+  virtual ~SpeechInputAPI();
+
+  // Convenience method to get the SpeechInputExtensionAPI for a profile.
+  static SpeechInputAPI* GetForProfile(Profile* profile);
+
+  // ProfileKeyedAPI implementation.
+  static ProfileKeyedAPIFactory<SpeechInputAPI>* GetFactoryInstance();
+
+  SpeechInputExtensionManager* manager() const { return manager_.get(); }
+
+ private:
+  friend class ProfileKeyedAPIFactory<SpeechInputAPI>;
+
+  // ProfileKeyedAPI implementation.
+  static const char* service_name() {
+    return "SpeechInputAPI";
+  }
+  static const bool kServiceIsNULLWhileTesting = true;
+  static const bool kServiceIsCreatedWithProfile = true;
+  // Methods from ProfileKeyedService.
+  virtual void Shutdown() OVERRIDE;
+
+  scoped_refptr<SpeechInputExtensionManager> manager_;
+};
+
+}  // namespace extensions
+
 #endif  // CHROME_BROWSER_SPEECH_SPEECH_INPUT_EXTENSION_MANAGER_H_