Speech refactoring: Reimplemented SpeechRecognitionManagerImpl as a FSM. (CL1.7)

content/browser/speech/speech_recognition_browsertest.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/speech/input_tag_speech_dispatcher_host.h"
 #include "content/browser/speech/speech_recognition_manager_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/speech_recognition_session_config.h"
+#include "content/public/browser/speech_recognition_session_context.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 
+using content::SpeechRecognitionEventListener;
+using content::SpeechRecognitionSessionContext;
 using content::NavigationController;
 using content::WebContents;
 
 namespace speech {
 class FakeSpeechRecognitionManager;
 }
 
 namespace speech {
 
 const char kTestResult[] = "Pictures of the moon";
 
 class FakeSpeechRecognitionManager : public SpeechRecognitionManagerImpl {
  public:
   FakeSpeechRecognitionManager()
       : session_id_(0),
-        delegate_(NULL),
+        listener_(NULL),
         did_cancel_all_(false),
         should_send_fake_response_(true),
         recognition_started_event_(false, false) {
   }
 
   std::string grammar() {
     return grammar_;
   }
 
   bool did_cancel_all() {
     return did_cancel_all_;
   }
 
   void set_should_send_fake_response(bool send) {
     should_send_fake_response_ = send;
   }
 
   bool should_send_fake_response() {
     return should_send_fake_response_;
   }
 
   base::WaitableEvent& recognition_started_event() {
     return recognition_started_event_;
   }
 
   // SpeechRecognitionManager methods.
-  virtual void StartRecognition(
-      InputTagSpeechDispatcherHost* delegate,
-      int session_id,
-      int render_process_id,
-      int render_view_id,
-      const gfx::Rect& element_rect,
-      const std::string& language,
-      const std::string& grammar,
-      const std::string& origin_url,
-      net::URLRequestContextGetter* context_getter,
-      content::SpeechRecognitionPreferences* recognition_prefs) OVERRIDE {
-    VLOG(1) << "StartRecognition invoked.";
+  virtual int CreateSession(
+      const content::SpeechRecognitionSessionConfig& config,
+      SpeechRecognitionEventListener* event_listener) OVERRIDE {
+    VLOG(1) << "FAKE CreateSession invoked.";
     EXPECT_EQ(0, session_id_);
-    EXPECT_EQ(NULL, delegate_);
-    session_id_ = session_id;
-    delegate_ = delegate;
-    grammar_ = grammar;
+    EXPECT_EQ(NULL, listener_);
+    listener_ = event_listener;
+    grammar_ = config.grammar;
+    session_ctx_ = config.initial_context;
+    session_id_ = 1;
+    return session_id_;
+  }
+
+  virtual void StartSession(int session_id) OVERRIDE {
+    VLOG(1) << "FAKE StartSession invoked.";
+    EXPECT_EQ(session_id, session_id_);
+    EXPECT_TRUE(listener_ != NULL);
+
     if (should_send_fake_response_) {
       // Give the fake result in a short while.
       MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
           &FakeSpeechRecognitionManager::SetFakeRecognitionResult,
           // This class does not need to be refcounted (typically done by
           // PostTask) since it will outlive the test and gets released only
           // when the test shuts down. Disabling refcounting here saves a bit
           // of unnecessary code and the factory method can return a plain
           // pointer below as required by the real code.
           base::Unretained(this)));
     }
     recognition_started_event_.Signal();
   }
-  virtual void CancelRecognition(int session_id) OVERRIDE {
-    VLOG(1) << "CancelRecognition invoked.";
+
+  virtual void AbortSession(int session_id) OVERRIDE {
+    VLOG(1) << "FAKE AbortSession invoked.";
     EXPECT_EQ(session_id_, session_id);
     session_id_ = 0;
-    delegate_ = NULL;
+    listener_ = NULL;
   }
-  virtual void StopRecording(int session_id) OVERRIDE {
+
+  virtual void StopAudioCaptureForSession(int session_id) OVERRIDE {
     VLOG(1) << "StopRecording invoked.";
     EXPECT_EQ(session_id_, session_id);
     // Nothing to do here since we aren't really recording.
   }
-  virtual void CancelAllRequestsWithDelegate(
-      InputTagSpeechDispatcherHost* delegate) OVERRIDE {
+
+  virtual void AbortAllSessionsForListener(
+      content::SpeechRecognitionEventListener* listener) OVERRIDE {
     VLOG(1) << "CancelAllRequestsWithDelegate invoked.";
-    // delegate_ is set to NULL if a fake result was received (see below), so
-    // check that delegate_ matches the incoming parameter only when there is
+    // listener_ is set to NULL if a fake result was received (see below), so
+    // check that listener_ matches the incoming parameter only when there is
     // no fake result sent.
-    EXPECT_TRUE(should_send_fake_response_ || delegate_ == delegate);
+    EXPECT_TRUE(should_send_fake_response_ || listener_ == listener);
     did_cancel_all_ = true;
   }
 
+  virtual void SendSessionToBackground(int session_id) OVERRIDE {}
+  virtual bool HasAudioInputDevices() OVERRIDE { return true; }
+  virtual bool IsCapturingAudio() OVERRIDE { return true; }
+  virtual string16 GetAudioInputDeviceModel() OVERRIDE { return string16(); }
+  virtual void ShowAudioInputSettings() OVERRIDE {}
+
+  virtual int LookupSessionByContext(
+      base::Callback<bool(
+          const content::SpeechRecognitionSessionContext&)> matcher)
+            const OVERRIDE {
+    bool matched = matcher.Run(session_ctx_);
+    return matched ? session_id_ : 0;
+  }
+
+  virtual content::SpeechRecognitionSessionContext GetSessionContext(
+      int session_id) const OVERRIDE {
+    EXPECT_EQ(session_id, session_id_);
+    return session_ctx_;
+  }
+
  private:
   void SetFakeRecognitionResult() {
     if (session_id_) {  // Do a check in case we were cancelled..
       VLOG(1) << "Setting fake recognition result.";
-      delegate_->DidCompleteRecording(session_id_);
+      listener_->OnAudioEnd(session_id_);
       content::SpeechRecognitionResult results;
       results.hypotheses.push_back(content::SpeechRecognitionHypothesis(
           ASCIIToUTF16(kTestResult), 1.0));
-      delegate_->SetRecognitionResult(session_id_, results);
-      delegate_->DidCompleteRecognition(session_id_);
+      listener_->OnRecognitionResult(session_id_, results);
+      listener_->OnRecognitionEnd(session_id_);
       session_id_ = 0;
-      delegate_ = NULL;
+      listener_ = NULL;
       VLOG(1) << "Finished setting fake recognition result.";
     }
   }
 
   int session_id_;
-  InputTagSpeechDispatcherHost* delegate_;
+  SpeechRecognitionEventListener* listener_;
+  SpeechRecognitionSessionContext session_ctx_;
   std::string grammar_;
   bool did_cancel_all_;
   bool should_send_fake_response_;
   base::WaitableEvent recognition_started_event_;
 };
 
 class SpeechRecognitionBrowserTest : public InProcessBrowserTest {
  public:
   // InProcessBrowserTest methods
   virtual void SetUpCommandLine(CommandLine* command_line) {
@@ skipping 101 matching lines @@
 
   // Make the renderer crash. This should trigger
   // InputTagSpeechDispatcherHost to cancel all pending sessions.
   GURL test_url("about:crash");
   ui_test_utils::NavigateToURL(browser(), test_url);
 
   EXPECT_TRUE(fake_speech_recognition_manager_.did_cancel_all());
 }
 
 }  // namespace speech