chrome/browser/speech/speech_input_extension_apitest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/command_line.h"
   7 #include "base/message_loop.h"
   8 #include "base/utf_string_conversions.h"
   9 #include "chrome/browser/extensions/extension_apitest.h"
  10 #include "chrome/browser/speech/speech_input_extension_api.h"
  11 #include "chrome/browser/speech/speech_input_extension_manager.h"
  12 #include "chrome/browser/ui/browser.h"
  13 #include "chrome/common/chrome_notification_types.h"
  14 #include "chrome/common/chrome_switches.h"
  15 #include "content/public/browser/speech_recognition_event_listener.h"
  16 #include "content/public/common/speech_recognition_error.h"
  17 #include "content/public/common/speech_recognition_result.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using content::BrowserThread;
  21
  22 namespace net {
  23 class URLRequestContextGetter;
  24 }
  25
  26 namespace {
  27 const int kSessionIDForTests = 0;
  28 }
  29
  30 // Mock class used to test the extension speech input API.
  31 class SpeechInputExtensionApiTest : public ExtensionApiTest,
  32                                     public SpeechInputExtensionInterface {
  33  public:
  34   SpeechInputExtensionApiTest();
  35   virtual ~SpeechInputExtensionApiTest();
  36
  37   void SetRecordingDevicesAvailable(bool available) {
  38     recording_devices_available_ = available;
  39   }
  40
  41   void SetRecognitionError(content::SpeechRecognitionErrorCode error) {
  42     next_error_ = error;
  43   }
  44
  45   void SetRecognitionResult(const content::SpeechRecognitionResult& result) {
  46     next_result_ = result;
  47   }
  48
  49   void SetRecognitionDelay(int result_delay_ms) {
  50     result_delay_ms_ = result_delay_ms;
  51   }
  52
  53   // Used as delay when the corresponding call should not be dispatched.
  54   static const int kDontDispatchCall = -1;
  55
  56   // InProcessBrowserTest methods.
  57   virtual void SetUpOnMainThread() OVERRIDE {
  58     manager_ = SpeechInputExtensionManager::GetForProfile(browser()->profile());
  59   }
  60
  61   // ExtensionApiTest methods.
  62   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  63     ExtensionApiTest::SetUpCommandLine(command_line);
  64     command_line->AppendSwitch(switches::kEnableExperimentalExtensionApis);
  65   }
  66
  67   // SpeechInputExtensionInterface methods.
  68   virtual bool HasAudioInputDevices() OVERRIDE {
  69     return recording_devices_available_;
  70   }
  71
  72   virtual bool IsCapturingAudio() OVERRIDE {
  73     // Only the mock recognizer is supposed to be recording during testing.
  74     return HasValidRecognizer();
  75   }
  76
  77   virtual bool HasValidRecognizer() OVERRIDE {
  78     return recognizer_is_valid_;
  79   }
  80
  81   virtual void StartRecording(
  82       content::SpeechRecognitionEventListener* listener,
  83       net::URLRequestContextGetter* context_getter,
  84       const std::string& extension_name,
  85       const std::string& language,
  86       const std::string& grammar,
  87       bool filter_profanities,
  88       int render_process_id) OVERRIDE;
  89
  90   virtual void StopRecording(bool recognition_failed) OVERRIDE;
  91
  92   SpeechInputExtensionManager* GetManager() {
  93     return manager_.get();
  94   }
  95
  96   // Auxiliary class used to hook the API manager into the test during its
  97   // lifetime. Required since browser() is not available during the set up
  98   // or tear down callbacks, or during the test class construction.
  99   class AutoManagerHook {
 100    public:
 101     explicit AutoManagerHook(SpeechInputExtensionApiTest* test)
 102         : test_(test) {
 103       test_->GetManager()->SetSpeechInputExtensionInterface(test_);
 104     }
 105
 106     ~AutoManagerHook() {
 107       test_->GetManager()->SetSpeechInputExtensionInterface(NULL);
 108     }
 109
 110    private:
 111     SpeechInputExtensionApiTest* test_;
 112   };
 113
 114  private:
 115   void ProvideResults();
 116
 117   bool recording_devices_available_;
 118   bool recognizer_is_valid_;
 119   content::SpeechRecognitionErrorCode next_error_;
 120   content::SpeechRecognitionResult next_result_;
 121   int result_delay_ms_;
 122
 123   scoped_refptr<SpeechInputExtensionManager> manager_;
 124 };
 125
 126 SpeechInputExtensionApiTest::SpeechInputExtensionApiTest()
 127     : recording_devices_available_(true),
 128       recognizer_is_valid_(false),
 129       next_error_(content::SPEECH_RECOGNITION_ERROR_NONE),
 130       result_delay_ms_(0) {
 131 }
 132
 133 SpeechInputExtensionApiTest::~SpeechInputExtensionApiTest() {
 134 }
 135
 136 void SpeechInputExtensionApiTest::StartRecording(
 137       content::SpeechRecognitionEventListener* listener,
 138       net::URLRequestContextGetter* context_getter,
 139       const std::string& extension_name,
 140       const std::string& language,
 141       const std::string& grammar,
 142       bool filter_profanities,
 143       int render_process_id) {
 144   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 145   recognizer_is_valid_ = true;
 146
 147   // Notify that recording started.
 148   MessageLoop::current()->PostDelayedTask(
 149       FROM_HERE,
 150       base::Bind(&SpeechInputExtensionManager::OnAudioStart,
 151                  GetManager(),
 152                  kSessionIDForTests),
 153       base::TimeDelta());
 154
 155   // Notify sound start in the input device.
 156   MessageLoop::current()->PostDelayedTask(
 157       FROM_HERE,
 158       base::Bind(&SpeechInputExtensionManager::OnSoundStart,
 159                  GetManager(),
 160                  kSessionIDForTests),
 161       base::TimeDelta());
 162
 163   if (result_delay_ms_ != kDontDispatchCall) {
 164     // Dispatch the recognition results.
 165     MessageLoop::current()->PostDelayedTask(
 166         FROM_HERE,
 167         base::Bind(&SpeechInputExtensionApiTest::ProvideResults, this),
 168         base::TimeDelta::FromMilliseconds(result_delay_ms_));
 169   }
 170 }
 171
 172 void SpeechInputExtensionApiTest::StopRecording(bool recognition_failed) {
 173   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 174   recognizer_is_valid_ = false;
 175 }
 176
 177 void SpeechInputExtensionApiTest::ProvideResults() {
 178   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 179
 180   if (next_error_ != content::SPEECH_RECOGNITION_ERROR_NONE) {
 181     GetManager()->OnRecognitionError(
 182         kSessionIDForTests, content::SpeechRecognitionError(next_error_));
 183     return;
 184   }
 185
 186   GetManager()->OnSoundEnd(kSessionIDForTests);
 187   GetManager()->OnAudioEnd(kSessionIDForTests);
 188   content::SpeechRecognitionResults results;
 189   results.push_back(next_result_);
 190   GetManager()->OnRecognitionResults(kSessionIDForTests, results);
 191   GetManager()->OnRecognitionEnd(kSessionIDForTests);
 192 }
 193
 194 // Every test should leave the manager in the idle state when finished.
 195 IN_PROC_BROWSER_TEST_F(SpeechInputExtensionApiTest, StartStopTest) {
 196   AutoManagerHook hook(this);
 197
 198   SetRecognitionDelay(kDontDispatchCall);
 199   ASSERT_TRUE(RunExtensionTest("speech_input/start_stop")) << message_;
 200 }
 201
 202 IN_PROC_BROWSER_TEST_F(SpeechInputExtensionApiTest, NoDevicesAvailable) {
 203   AutoManagerHook hook(this);
 204
 205   SetRecordingDevicesAvailable(false);
 206   ASSERT_TRUE(RunExtensionTest("speech_input/start_error")) << message_;
 207 }
 208
 209 IN_PROC_BROWSER_TEST_F(SpeechInputExtensionApiTest, RecognitionSuccessful) {
 210   AutoManagerHook hook(this);
 211
 212   content::SpeechRecognitionResult result;
 213   result.hypotheses.push_back(
 214       content::SpeechRecognitionHypothesis(
 215           UTF8ToUTF16("this is a test"), 0.99));
 216   SetRecognitionResult(result);
 217   ASSERT_TRUE(RunExtensionTest("speech_input/recognition")) << message_;
 218 }
 219
 220 IN_PROC_BROWSER_TEST_F(SpeechInputExtensionApiTest, RecognitionError) {
 221   AutoManagerHook hook(this);
 222
 223   SetRecognitionError(content::SPEECH_RECOGNITION_ERROR_NETWORK);
 224   ASSERT_TRUE(RunExtensionTest("speech_input/recognition_error")) << message_;
 225 }