Moved instantiation of SpeechRecognitionManager inside browser_main_loop, instead of Singleton.

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_manager.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::SpeechRecognitionSessionConfig;
 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 {
+class FakeSpeechRecognitionManager : public content::SpeechRecognitionManager {
  public:
   FakeSpeechRecognitionManager()
       : session_id_(0),
         listener_(NULL),
         did_cancel_all_(false),
         should_send_fake_response_(true),
         recognition_started_event_(false, false) {
   }
 
   std::string grammar() {
@@ skipping 19 matching lines @@
   // SpeechRecognitionManager methods.
   virtual int CreateSession(
       const content::SpeechRecognitionSessionConfig& config) OVERRIDE {
     VLOG(1) << "FAKE CreateSession invoked.";
     EXPECT_EQ(0, session_id_);
     EXPECT_EQ(NULL, listener_);
     listener_ = config.event_listener;
     if (config.grammars.size() > 0)
       grammar_ = config.grammars[0].url;
     session_ctx_ = config.initial_context;
+    session_config_ = config;
     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_) {
@@ skipping 39 matching lines @@
   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 const SpeechRecognitionSessionConfig& GetSessionConfig(
+      int session_id) const OVERRIDE {
+    EXPECT_EQ(session_id, session_id_);
+    return session_config_;
+  }
+
   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.";
       listener_->OnAudioEnd(session_id_);
       content::SpeechRecognitionResult results;
       results.hypotheses.push_back(content::SpeechRecognitionHypothesis(
           ASCIIToUTF16(kTestResult), 1.0));
       listener_->OnRecognitionResult(session_id_, results);
       listener_->OnRecognitionEnd(session_id_);
       session_id_ = 0;
       listener_ = NULL;
       VLOG(1) << "Finished setting fake recognition result.";
     }
   }
 
   int session_id_;
   SpeechRecognitionEventListener* listener_;
+  SpeechRecognitionSessionConfig session_config_;
   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
@@ skipping 46 matching lines @@
     EXPECT_EQ("pass", browser()->GetSelectedWebContents()->GetURL().ref());
   }
 
   // InProcessBrowserTest methods.
   virtual void SetUpInProcessBrowserTestFixture() {
     fake_speech_recognition_manager_.set_should_send_fake_response(true);
     speech_recognition_manager_ = &fake_speech_recognition_manager_;
 
     // Inject the fake manager factory so that the test result is returned to
     // the web page.
-    InputTagSpeechDispatcherHost::set_manager(speech_recognition_manager_);
+    InputTagSpeechDispatcherHost::SetManagerForTests(
+        speech_recognition_manager_);
   }
 
   virtual void TearDownInProcessBrowserTestFixture() {
     speech_recognition_manager_ = NULL;
   }
 
   FakeSpeechRecognitionManager fake_speech_recognition_manager_;
 
   // This is used by the static |fakeManager|, and it is a pointer rather than a
   // direct instance per the style guide.
-  static SpeechRecognitionManagerImpl* speech_recognition_manager_;
+  static content::SpeechRecognitionManager* speech_recognition_manager_;
 };
 
-SpeechRecognitionManagerImpl*
+content::SpeechRecognitionManager*
     SpeechRecognitionBrowserTest::speech_recognition_manager_ = NULL;
 
 // TODO(satish): Once this flakiness has been fixed, add a second test here to
 // check for sending many clicks in succession to the speech button and verify
 // that it doesn't cause any crash but works as expected. This should act as the
 // test for http://crbug.com/59173
 //
 // TODO(satish): Similar to above, once this flakiness has been fixed add
 // another test here to check that when speech recognition is in progress and
 // a renderer crashes, we get a call to
@@ skipping 21 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