App a Content API around SpeechRecognizer.

BUG=98716
Review URL: https://chromiumcodereview.appspot.com/9453023

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@123328 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 158 insertions, 109 deletions

diff --git a/chrome/browser/DEPS b/chrome/browser/DEPS
index 59cedee..3715777 100644
--- a/chrome/browser/DEPS
+++ b/chrome/browser/DEPS
@@ -83,7 +83,6 @@ include_rules = [
   "+content/browser/renderer_host/resource_request_details.h",
   "+content/browser/renderer_host/test_render_view_host.h",
   "+content/browser/speech/speech_input_manager.h",
-  "+content/browser/speech/speech_recognizer.h",
   "+content/browser/tab_contents/popup_menu_helper_mac.h",
   "+content/browser/tab_contents/provisional_load_details.h",
   "+content/browser/tab_contents/tab_contents_view_gtk.h",
diff --git a/chrome/browser/speech/speech_input_extension_manager.cc b/chrome/browser/speech/speech_input_extension_manager.cc
index d9eabf6..172d4b5 100644
--- a/chrome/browser/speech/speech_input_extension_manager.cc
+++ b/chrome/browser/speech/speech_input_extension_manager.cc
@@ -20,15 +20,14 @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
-#include "content/browser/speech/speech_recognizer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/speech_recognizer.h"
 #include "content/public/common/speech_input_result.h"
 
 using content::BrowserThread;
 using speech_input::ChromeSpeechInputManager;
-using speech_input::SpeechRecognizer;
 
 namespace {
 
@@ -602,8 +601,9 @@ void SpeechInputExtensionManager::StartRecording(
     bool filter_profanities) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!recognizer_);
-  recognizer_ = new SpeechRecognizer(delegate, caller_id, language, grammar,
-      context_getter, filter_profanities, "", "");
+  recognizer_ = content::SpeechRecognizer::Create(
+      delegate, caller_id, language, grammar, context_getter,
+      filter_profanities, "", "");
   recognizer_->StartRecording();
 }
 
diff --git a/chrome/browser/speech/speech_input_extension_manager.h b/chrome/browser/speech/speech_input_extension_manager.h
index ad3e1fb..a6f3b14 100644
--- a/chrome/browser/speech/speech_input_extension_manager.h
+++ b/chrome/browser/speech/speech_input_extension_manager.h
@@ -21,16 +21,13 @@ class SpeechInputExtensionNotification;
 
 namespace content {
 class NotificationRegistrar;
+class SpeechRecognizer;
 }
 
 namespace net {
 class URLRequestContextGetter;
 }
 
-namespace speech_input {
-class SpeechRecognizer;
-}
-
 // Used for API tests.
 class SpeechInputExtensionInterface {
  public:
@@ -52,9 +49,6 @@ class SpeechInputExtensionInterface {
 
   // Called from the UI thread.
   virtual bool HasValidRecognizer() = 0;
-
- protected:
-  scoped_refptr<speech_input::SpeechRecognizer> recognizer_;
 };
 
 // Manages the speech input requests and responses from the extensions
@@ -204,6 +198,9 @@ class SpeechInputExtensionManager
   scoped_ptr<content::NotificationRegistrar> registrar_;
   SpeechInputExtensionInterface* speech_interface_;
   scoped_ptr<SpeechInputExtensionNotification> notification_;
+
+  // Used in the IO thread.
+  scoped_refptr<content::SpeechRecognizer> recognizer_;
 };
 
 #endif  // CHROME_BROWSER_SPEECH_SPEECH_INPUT_EXTENSION_MANAGER_H_
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index 38d7202..2cbe582 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -115,7 +115,6 @@
 
 #if defined(ENABLE_INPUT_SPEECH)
 #include "content/browser/speech/speech_input_dispatcher_host.h"
-#include "content/browser/speech/speech_recognizer.h"
 #endif
 
 #include "third_party/skia/include/core/SkBitmap.h"
diff --git a/content/browser/speech/speech_input_dispatcher_host.cc b/content/browser/speech/speech_input_dispatcher_host.cc
index 1660f46..62d212d 100644
--- a/content/browser/speech/speech_input_dispatcher_host.cc
+++ b/content/browser/speech/speech_input_dispatcher_host.cc
@@ -6,7 +6,7 @@
 
 #include "base/lazy_instance.h"
 #include "content/browser/speech/speech_input_manager.h"
-#include "content/browser/speech/speech_recognizer.h"
+#include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/common/speech_input_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/speech_input_preferences.h"
diff --git a/content/browser/speech/speech_input_manager.cc b/content/browser/speech/speech_input_manager.cc
index 4b7b9fb..95b85db 100644
--- a/content/browser/speech/speech_input_manager.cc
+++ b/content/browser/speech/speech_input_manager.cc
@@ -8,7 +8,7 @@
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/speech/speech_input_manager_delegate.h"
-#include "content/browser/speech/speech_recognizer.h"
+#include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/resource_context.h"
@@ -163,7 +163,7 @@ void SpeechInputManager::ProceedStartingRecognition(
 
   SpeechInputRequest* request = &requests_[params.caller_id];
   request->delegate = params.delegate;
-  request->recognizer = new SpeechRecognizer(
+  request->recognizer = new SpeechRecognizerImpl(
       this, params.caller_id, params.language, params.grammar,
       params.context_getter, params.speech_input_prefs->FilterProfanities(),
       request_info_, can_report_metrics_ ? params.origin_url : "");
diff --git a/content/browser/speech/speech_input_manager.h b/content/browser/speech/speech_input_manager.h
index 186b969..522b762 100644
--- a/content/browser/speech/speech_input_manager.h
+++ b/content/browser/speech/speech_input_manager.h
@@ -30,7 +30,7 @@ class URLRequestContextGetter;
 
 namespace speech_input {
 
-class SpeechRecognizer;
+class SpeechRecognizerImpl;
 
 // This is the gatekeeper for speech recognition in the browser process. It
 // handles requests received from various render views and makes sure only one
@@ -153,7 +153,7 @@ class CONTENT_EXPORT SpeechInputManager
     ~SpeechInputRequest();
 
     content::SpeechInputManagerDelegate* delegate;
-    scoped_refptr<SpeechRecognizer> recognizer;
+    scoped_refptr<SpeechRecognizerImpl> recognizer;
     bool is_active;  // Set to true when recording or recognition is going on.
   };
 
diff --git a/content/browser/speech/speech_recognizer.cc b/content/browser/speech/speech_recognizer_impl.cc
index b3f1716..9d4ed1c 100644
--- a/content/browser/speech/speech_recognizer.cc
+++ b/content/browser/speech/speech_recognizer_impl.cc
@@ -2,7 +2,7 @@
 // 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_recognizer.h"
+#include "content/browser/speech/speech_recognizer_impl.h"
 
 #include "base/bind.h"
 #include "base/time.h"
@@ -14,6 +14,8 @@
 
 using content::BrowserMainLoop;
 using content::BrowserThread;
+using content::SpeechRecognizer;
+using content::SpeechRecognizerDelegate;
 using media::AudioInputController;
 using std::string;
 
@@ -50,23 +52,38 @@ bool Clipping(const int16* samples, int num_samples) {
 
 }  // namespace
 
+SpeechRecognizer* SpeechRecognizer::Create(
+    SpeechRecognizerDelegate* delegate,
+    int caller_id,
+    const std::string& language,
+    const std::string& grammar,
+    net::URLRequestContextGetter* context_getter,
+    bool filter_profanities,
+    const std::string& hardware_info,
+    const std::string& origin_url) {
+  return new speech_input::SpeechRecognizerImpl(
+      delegate, caller_id, language, grammar, context_getter,
+      filter_profanities, hardware_info, origin_url);
+}
+
 namespace speech_input {
 
-const int SpeechRecognizer::kAudioSampleRate = 16000;
-const int SpeechRecognizer::kAudioPacketIntervalMs = 100;
-const ChannelLayout SpeechRecognizer::kChannelLayout = CHANNEL_LAYOUT_MONO;
-const int SpeechRecognizer::kNumBitsPerAudioSample = 16;
-const int SpeechRecognizer::kNoSpeechTimeoutSec = 8;
-const int SpeechRecognizer::kEndpointerEstimationTimeMs = 300;
-
-SpeechRecognizer::SpeechRecognizer(content::SpeechRecognizerDelegate* delegate,
-                                   int caller_id,
-                                   const std::string& language,
-                                   const std::string& grammar,
-                                   net::URLRequestContextGetter* context_getter,
-                                   bool filter_profanities,
-                                   const std::string& hardware_info,
-                                   const std::string& origin_url)
+const int SpeechRecognizerImpl::kAudioSampleRate = 16000;
+const int SpeechRecognizerImpl::kAudioPacketIntervalMs = 100;
+const ChannelLayout SpeechRecognizerImpl::kChannelLayout = CHANNEL_LAYOUT_MONO;
+const int SpeechRecognizerImpl::kNumBitsPerAudioSample = 16;
+const int SpeechRecognizerImpl::kNoSpeechTimeoutSec = 8;
+const int SpeechRecognizerImpl::kEndpointerEstimationTimeMs = 300;
+
+SpeechRecognizerImpl::SpeechRecognizerImpl(
+    SpeechRecognizerDelegate* delegate,
+    int caller_id,
+    const std::string& language,
+    const std::string& grammar,
+    net::URLRequestContextGetter* context_getter,
+    bool filter_profanities,
+    const std::string& hardware_info,
+    const std::string& origin_url)
     : delegate_(delegate),
       caller_id_(caller_id),
       language_(language),
@@ -89,7 +106,7 @@ SpeechRecognizer::SpeechRecognizer(content::SpeechRecognizerDelegate* delegate,
   endpointer_.StartSession();
 }
 
-SpeechRecognizer::~SpeechRecognizer() {
+SpeechRecognizerImpl::~SpeechRecognizerImpl() {
   // Recording should have stopped earlier due to the endpointer or
   // |StopRecording| being called.
   DCHECK(!audio_controller_.get());
@@ -98,7 +115,7 @@ SpeechRecognizer::~SpeechRecognizer() {
   endpointer_.EndSession();
 }
 
-bool SpeechRecognizer::StartRecording() {
+bool SpeechRecognizerImpl::StartRecording() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!audio_controller_.get());
   DCHECK(!request_.get() || !request_->HasPendingRequest());
@@ -126,7 +143,7 @@ bool SpeechRecognizer::StartRecording() {
   return true;
 }
 
-void SpeechRecognizer::CancelRecognition() {
+void SpeechRecognizerImpl::CancelRecognition() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(audio_controller_.get() || request_.get());
 
@@ -140,7 +157,7 @@ void SpeechRecognizer::CancelRecognition() {
   request_.reset();
 }
 
-void SpeechRecognizer::StopRecording() {
+void SpeechRecognizerImpl::StopRecording() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // If audio recording has already stopped and we are in recognition phase,
@@ -167,7 +184,7 @@ void SpeechRecognizer::StopRecording() {
   // If we haven't got any audio yet end the recognition sequence here.
   if (request_ == NULL) {
     // Guard against the delegate freeing us until we finish our job.
-    scoped_refptr<SpeechRecognizer> me(this);
+    scoped_refptr<SpeechRecognizerImpl> me(this);
     delegate_->DidCompleteRecognition(caller_id_);
   } else {
     request_->UploadAudioChunk(encoded_data, true /* is_last_chunk */);
@@ -175,14 +192,14 @@ void SpeechRecognizer::StopRecording() {
 }
 
 // Invoked in the audio thread.
-void SpeechRecognizer::OnError(AudioInputController* controller,
-                               int error_code) {
+void SpeechRecognizerImpl::OnError(AudioInputController* controller,
+                                   int error_code) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                         base::Bind(&SpeechRecognizer::HandleOnError,
+                         base::Bind(&SpeechRecognizerImpl::HandleOnError,
                                     this, error_code));
 }
 
-void SpeechRecognizer::HandleOnError(int error_code) {
+void SpeechRecognizerImpl::HandleOnError(int error_code) {
   LOG(WARNING) << "SpeechRecognizer::HandleOnError, code=" << error_code;
 
   // Check if we are still recording before canceling recognition, as
@@ -194,18 +211,18 @@ void SpeechRecognizer::HandleOnError(int error_code) {
   InformErrorAndCancelRecognition(content::SPEECH_INPUT_ERROR_AUDIO);
 }
 
-void SpeechRecognizer::OnData(AudioInputController* controller,
-                              const uint8* data, uint32 size) {
+void SpeechRecognizerImpl::OnData(AudioInputController* controller,
+                                  const uint8* data, uint32 size) {
   if (size == 0)  // This could happen when recording stops and is normal.
     return;
 
   string* str_data = new string(reinterpret_cast<const char*>(data), size);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&SpeechRecognizer::HandleOnData,
+                          base::Bind(&SpeechRecognizerImpl::HandleOnData,
                                      this, str_data));
 }
 
-void SpeechRecognizer::HandleOnData(string* data) {
+void SpeechRecognizerImpl::HandleOnData(string* data) {
   // Check if we are still recording and if not discard this buffer, as
   // recording might have been stopped after this buffer was posted to the queue
   // by |OnData|.
@@ -285,7 +302,7 @@ void SpeechRecognizer::HandleOnData(string* data) {
     StopRecording();
 }
 
-void SpeechRecognizer::SetRecognitionResult(
+void SpeechRecognizerImpl::SetRecognitionResult(
     const content::SpeechInputResult& result) {
   if (result.error != content::SPEECH_INPUT_ERROR_NONE) {
     InformErrorAndCancelRecognition(result.error);
@@ -293,22 +310,22 @@ void SpeechRecognizer::SetRecognitionResult(
   }
 
   // Guard against the delegate freeing us until we finish our job.
-  scoped_refptr<SpeechRecognizer> me(this);
+  scoped_refptr<SpeechRecognizerImpl> me(this);
   delegate_->SetRecognitionResult(caller_id_, result);
   delegate_->DidCompleteRecognition(caller_id_);
 }
 
-void SpeechRecognizer::InformErrorAndCancelRecognition(
+void SpeechRecognizerImpl::InformErrorAndCancelRecognition(
     content::SpeechInputError error) {
   DCHECK_NE(error, content::SPEECH_INPUT_ERROR_NONE);
   CancelRecognition();
 
   // Guard against the delegate freeing us until we finish our job.
-  scoped_refptr<SpeechRecognizer> me(this);
+  scoped_refptr<SpeechRecognizerImpl> me(this);
   delegate_->OnRecognizerError(caller_id_, error);
 }
 
-void SpeechRecognizer::CloseAudioControllerSynchronously() {
+void SpeechRecognizerImpl::CloseAudioControllerSynchronously() {
   VLOG(1) << "SpeechRecognizer stopping record.";
 
   // TODO(satish): investigate the possibility to utilize the closure
@@ -321,7 +338,8 @@ void SpeechRecognizer::CloseAudioControllerSynchronously() {
   audio_controller_ = NULL;  // Releases the ref ptr.
 }
 
-void SpeechRecognizer::SetAudioManagerForTesting(AudioManager* audio_manager) {
+void SpeechRecognizerImpl::SetAudioManagerForTesting(
+    AudioManager* audio_manager) {
   audio_manager_ = audio_manager;
 }
 
diff --git a/content/browser/speech/speech_recognizer.h b/content/browser/speech/speech_recognizer_impl.h
index 23c2814..0273ccb 100644
--- a/content/browser/speech/speech_recognizer.h
+++ b/content/browser/speech/speech_recognizer_impl.h
@@ -2,66 +2,50 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_H_
-#define CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_H_
+#ifndef CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_
+#define CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_
 
 #include <list>
-#include <string>
 #include <utility>
 
-#include "base/memory/ref_counted.h"
+#include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/speech/audio_encoder.h"
 #include "content/browser/speech/endpointer/endpointer.h"
 #include "content/browser/speech/speech_recognition_request.h"
-#include "content/common/content_export.h"
+#include "content/public/browser/speech_recognizer.h"
 #include "content/public/common/speech_input_result.h"
 #include "media/audio/audio_input_controller.h"
 
 class AudioManager;
 
-namespace content {
-class SpeechRecognizerDelegate;
-}
-
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace speech_input {
 
 // Records audio, sends recorded audio to server and translates server response
 // to recognition result.
-class CONTENT_EXPORT SpeechRecognizer
-    : public base::RefCountedThreadSafe<SpeechRecognizer>,
+class CONTENT_EXPORT SpeechRecognizerImpl
+    : NON_EXPORTED_BASE(public content::SpeechRecognizer),
       public media::AudioInputController::EventHandler,
       public SpeechRecognitionRequestDelegate {
  public:
-  SpeechRecognizer(content::SpeechRecognizerDelegate* delegate,
-                   int caller_id,
-                   const std::string& language,
-                   const std::string& grammar,
-                   net::URLRequestContextGetter* context_getter,
-                   bool filter_profanities,
-                   const std::string& hardware_info,
-                   const std::string& origin_url);
-
-  virtual ~SpeechRecognizer();
-
-  // Starts audio recording and does recognition after recording ends. The same
-  // SpeechRecognizer instance can be used multiple times for speech recognition
-  // though each recognition request can be made only after the previous one
-  // completes (i.e. after receiving
-  // SpeechRecognizerDelegate::DidCompleteRecognition).
-  bool StartRecording();
+  SpeechRecognizerImpl(content::SpeechRecognizerDelegate* delegate,
+                       int caller_id,
+                       const std::string& language,
+                       const std::string& grammar,
+                       net::URLRequestContextGetter* context_getter,
+                       bool filter_profanities,
+                       const std::string& hardware_info,
+                       const std::string& origin_url);
+
+  virtual ~SpeechRecognizerImpl();
+
+  // SpeechRecognizer implementation:
+  virtual bool StartRecording() OVERRIDE;
+  virtual void CancelRecognition() OVERRIDE;
 
   // Stops recording audio and starts recognition.
   void StopRecording();
 
-  // Stops recording audio and cancels recognition. Any audio recorded so far
-  // gets discarded.
-  void CancelRecognition();
-
   // AudioInputController::EventHandler methods.
   virtual void OnCreated(media::AudioInputController* controller) OVERRIDE { }
   virtual void OnRecording(media::AudioInputController* controller) OVERRIDE { }
@@ -116,9 +100,9 @@ class CONTENT_EXPORT SpeechRecognizer
   float audio_level_;
   AudioManager* audio_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpeechRecognizer);
+  DISALLOW_COPY_AND_ASSIGN(SpeechRecognizerImpl);
 };
 
 }  // namespace speech_input
 
-#endif  // CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_H_
+#endif  // CONTENT_BROWSER_SPEECH_SPEECH_RECOGNIZER_IMPL_H_
diff --git a/content/browser/speech/speech_recognizer_unittest.cc b/content/browser/speech/speech_recognizer_impl_unittest.cc
index 948d397..7388914 100644
--- a/content/browser/speech/speech_recognizer_unittest.cc
+++ b/content/browser/speech/speech_recognizer_impl_unittest.cc
@@ -5,7 +5,7 @@
 #include <vector>
 
 #include "content/browser/browser_thread_impl.h"
-#include "content/browser/speech/speech_recognizer.h"
+#include "content/browser/speech/speech_recognizer_impl.h"
 #include "content/public/browser/speech_recognizer_delegate.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "media/audio/audio_manager.h"
@@ -34,15 +34,15 @@ class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
         audio_received_(false),
         error_(content::SPEECH_INPUT_ERROR_NONE),
         volume_(-1.0f) {
-    recognizer_ = new SpeechRecognizer(this, 1, std::string(), std::string(),
-                                       NULL, false, std::string(),
-                                       std::string());
+    recognizer_ = new SpeechRecognizerImpl(
+        this, 1, std::string(), std::string(), NULL, false, std::string(),
+        std::string());
     recognizer_->SetAudioManagerForTesting(audio_manager_.get());
     int audio_packet_length_bytes =
-        (SpeechRecognizer::kAudioSampleRate *
-         SpeechRecognizer::kAudioPacketIntervalMs *
-         ChannelLayoutToChannelCount(SpeechRecognizer::kChannelLayout) *
-         SpeechRecognizer::kNumBitsPerAudioSample) / (8 * 1000);
+        (SpeechRecognizerImpl::kAudioSampleRate *
+         SpeechRecognizerImpl::kAudioPacketIntervalMs *
+         ChannelLayoutToChannelCount(SpeechRecognizerImpl::kChannelLayout) *
+         SpeechRecognizerImpl::kNumBitsPerAudioSample) / (8 * 1000);
     audio_packet_.resize(audio_packet_length_bytes);
   }
 
@@ -113,7 +113,7 @@ class SpeechRecognizerTest : public content::SpeechRecognizerDelegate,
  protected:
   MessageLoopForIO message_loop_;
   BrowserThreadImpl io_thread_;
-  scoped_refptr<SpeechRecognizer> recognizer_;
+  scoped_refptr<SpeechRecognizerImpl> recognizer_;
   scoped_ptr<AudioManager> audio_manager_;
   bool recording_complete_;
   bool recognition_complete_;
@@ -329,8 +329,8 @@ TEST_F(SpeechRecognizerTest, NoSpeechCallbackIssued) {
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
-  int num_packets = (SpeechRecognizer::kNoSpeechTimeoutSec * 1000) /
-                     SpeechRecognizer::kAudioPacketIntervalMs;
+  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutSec * 1000) /
+                     SpeechRecognizerImpl::kAudioPacketIntervalMs;
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets; ++i) {
     controller->event_handler()->OnData(controller, &audio_packet_[0],
@@ -356,8 +356,8 @@ TEST_F(SpeechRecognizerTest, NoSpeechCallbackNotIssued) {
   controller = audio_input_controller_factory_.controller();
   ASSERT_TRUE(controller);
 
-  int num_packets = (SpeechRecognizer::kNoSpeechTimeoutSec * 1000) /
-                     SpeechRecognizer::kAudioPacketIntervalMs;
+  int num_packets = (SpeechRecognizerImpl::kNoSpeechTimeoutSec * 1000) /
+                     SpeechRecognizerImpl::kAudioPacketIntervalMs;
 
   // The vector is already filled with zero value samples on create.
   for (int i = 0; i < num_packets / 2; ++i) {
@@ -392,8 +392,8 @@ TEST_F(SpeechRecognizerTest, SetInputVolumeCallback) {
   ASSERT_TRUE(controller);
 
   // Feed some samples to begin with for the endpointer to do noise estimation.
-  int num_packets = SpeechRecognizer::kEndpointerEstimationTimeMs /
-                    SpeechRecognizer::kAudioPacketIntervalMs;
+  int num_packets = SpeechRecognizerImpl::kEndpointerEstimationTimeMs /
+                    SpeechRecognizerImpl::kAudioPacketIntervalMs;
   FillPacketWithNoise();
   for (int i = 0; i < num_packets; ++i) {
     controller->event_handler()->OnData(controller, &audio_packet_[0],
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index 864fb9a..75d5171 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -110,6 +110,7 @@
     'public/browser/sensors_provider.h',
     'public/browser/site_instance.h',
     'public/browser/speech_input_preferences.h',
+    'public/browser/speech_recognizer.h',
     'public/browser/speech_recognizer_delegate.h',
     'public/browser/user_metrics.h',
     'public/browser/utility_process_host.h',
@@ -606,8 +607,8 @@
     'browser/speech/speech_input_manager_delegate.h',
     'browser/speech/speech_recognition_request.cc',
     'browser/speech/speech_recognition_request.h',
-    'browser/speech/speech_recognizer.cc',
-    'browser/speech/speech_recognizer.h',
+    'browser/speech/speech_recognizer_impl.cc',
+    'browser/speech/speech_recognizer_impl.h',
     'browser/ssl/ssl_cert_error_handler.cc',
     'browser/ssl/ssl_cert_error_handler.h',
     'browser/ssl/ssl_client_auth_handler.cc',
diff --git a/content/content_tests.gypi b/content/content_tests.gypi
index 8847de3..ab06490 100644
--- a/content/content_tests.gypi
+++ b/content/content_tests.gypi
@@ -246,7 +246,7 @@
         'browser/site_instance_impl_unittest.cc',
         'browser/speech/endpointer/endpointer_unittest.cc',
         'browser/speech/speech_recognition_request_unittest.cc',
-        'browser/speech/speech_recognizer_unittest.cc',
+        'browser/speech/speech_recognizer_impl_unittest.cc',
         'browser/ssl/ssl_host_state_unittest.cc',
         'browser/tab_contents/navigation_controller_impl_unittest.cc',
         'browser/tab_contents/navigation_entry_impl_unittest.cc',
diff --git a/content/public/browser/speech_recognizer.h b/content/public/browser/speech_recognizer.h
new file mode 100644
index 0000000..32a8069
--- /dev/null
+++ b/content/public/browser/speech_recognizer.h
@@ -0,0 +1,51 @@
+// 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 CONTENT_PUBLIC_BROWSER_SPEECH_RECOGNIZER_H_
+#define CONTENT_PUBLIC_BROWSER_SPEECH_RECOGNIZER_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "content/common/content_export.h"
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace content {
+
+class SpeechRecognizerDelegate;
+
+// Records audio, sends recorded audio to server and translates server response
+// to recognition result.
+class SpeechRecognizer : public base::RefCountedThreadSafe<SpeechRecognizer> {
+ public:
+  CONTENT_EXPORT static SpeechRecognizer* Create(
+      SpeechRecognizerDelegate* delegate,
+      int caller_id,
+      const std::string& language,
+      const std::string& grammar,
+      net::URLRequestContextGetter* context_getter,
+      bool filter_profanities,
+      const std::string& hardware_info,
+      const std::string& origin_url);
+
+  virtual ~SpeechRecognizer() {}
+
+  // Starts audio recording and does recognition after recording ends. The same
+  // SpeechRecognizer instance can be used multiple times for speech recognition
+  // though each recognition request can be made only after the previous one
+  // completes (i.e. after receiving
+  // SpeechRecognizerDelegate::DidCompleteRecognition).
+  virtual bool StartRecording() = 0;
+
+  // Stops recording audio and cancels recognition. Any audio recorded so far
+  // gets discarded.
+  virtual void CancelRecognition() = 0;
+};
+
+}  // namespace speech_input
+
+#endif  // CONTENT_PUBLIC_BROWSER_SPEECH_RECOGNIZER_H_