content/browser: Move speech code into content namespace.

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/message_loop.h"
 #include "base/string_number_conversions.h"
@@ skipping 10 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/speech_recognition_error.h"
 #include "content/public/common/speech_recognition_result.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/shell.h"
 #include "content/test/content_browser_test.h"
 #include "content/test/content_browser_test_utils.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 
-using content::NavigationController;
-using content::SpeechRecognitionEventListener;
-using content::SpeechRecognitionSessionConfig;
-using content::SpeechRecognitionSessionContext;
-using content::WebContents;
-
-namespace speech {
-class FakeSpeechRecognitionManager;
-}
-
-namespace speech {
+namespace content {
 
 const char kTestResult[] = "Pictures of the moon";
 
-class FakeSpeechRecognitionManager : public content::SpeechRecognitionManager {
+class FakeSpeechRecognitionManager : public 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 11 matching lines @@
   bool should_send_fake_response() {
     return should_send_fake_response_;
   }
 
   base::WaitableEvent& recognition_started_event() {
     return recognition_started_event_;
   }
 
   // SpeechRecognitionManager methods.
   virtual int CreateSession(
-      const content::SpeechRecognitionSessionConfig& config) OVERRIDE {
+      const 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_;
@@ skipping 25 matching lines @@
     listener_ = NULL;
   }
 
   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 AbortAllSessionsForListener(
-      content::SpeechRecognitionEventListener* listener) OVERRIDE {
+      SpeechRecognitionEventListener* listener) OVERRIDE {
     VLOG(1) << "CancelAllRequestsWithDelegate invoked.";
     // 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_ || listener_ == listener);
     did_cancel_all_ = true;
   }
 
   virtual void AbortAllSessionsForRenderView(int render_process_id,
                                              int render_view_id) OVERRIDE {
@@ skipping 11 matching lines @@
            session_ctx_.render_view_id == render_view_id &&
            session_ctx_.request_id == request_id;
   }
 
   virtual const SpeechRecognitionSessionConfig& GetSessionConfig(
       int session_id) const OVERRIDE {
     EXPECT_EQ(session_id, session_id_);
     return session_config_;
   }
 
-  virtual content::SpeechRecognitionSessionContext GetSessionContext(
+  virtual 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(
+      SpeechRecognitionResult results;
+      results.hypotheses.push_back(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 content::ContentBrowserTest {
+class SpeechRecognitionBrowserTest : public ContentBrowserTest {
  public:
   // ContentBrowserTest methods
   virtual void SetUpCommandLine(CommandLine* command_line) {
     EXPECT_TRUE(!command_line->HasSwitch(switches::kDisableSpeechInput));
   }
 
  protected:
   void LoadAndStartSpeechRecognitionTest(const char* filename) {
     // The test page calculates the speech button's coordinate in the page on
     // load & sets that coordinate in the URL fragment. We send mouse down & up
     // events at that coordinate to trigger speech recognition.
-    GURL test_url = content::GetTestUrl("speech", filename);
-    content::NavigateToURL(shell(), test_url);
+    GURL test_url = GetTestUrl("speech", filename);
+    NavigateToURL(shell(), test_url);
 
     WebKit::WebMouseEvent mouse_event;
     mouse_event.type = WebKit::WebInputEvent::MouseDown;
     mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
     mouse_event.x = 0;
     mouse_event.y = 0;
     mouse_event.clickCount = 1;
     WebContents* web_contents = shell()->web_contents();
 
-    content::WindowedNotificationObserver observer(
-        content::NOTIFICATION_LOAD_STOP,
-        content::Source<NavigationController>(&web_contents->GetController()));
+    WindowedNotificationObserver observer(
+        NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&web_contents->GetController()));
     web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
     mouse_event.type = WebKit::WebInputEvent::MouseUp;
     web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
     fake_speech_recognition_manager_.recognition_started_event().Wait();
 
     // We should wait for a navigation event, raised by the test page JS code
     // upon the onwebkitspeechchange event, in all cases except when the
     // speech response is inhibited.
     if (fake_speech_recognition_manager_.should_send_fake_response())
       observer.Wait();
@@ skipping 20 matching lines @@
   }
 
   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 content::SpeechRecognitionManager* speech_recognition_manager_;
+  static SpeechRecognitionManager* speech_recognition_manager_;
 };
 
-content::SpeechRecognitionManager*
+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 14 matching lines @@
   // The test checks that the cancel-all callback gets issued when a session
   // is pending, so don't send a fake response.
   // We are not expecting a navigation event being raised from the JS of the
   // test page JavaScript in this case.
   fake_speech_recognition_manager_.set_should_send_fake_response(false);
 
   LoadAndStartSpeechRecognitionTest("basic_recognition.html");
 
   // Make the renderer crash. This should trigger
   // InputTagSpeechDispatcherHost to cancel all pending sessions.
-  content::NavigateToURL(shell(), GURL(chrome::kChromeUICrashURL));
+  NavigateToURL(shell(), GURL(chrome::kChromeUICrashURL));
 
   EXPECT_TRUE(fake_speech_recognition_manager_.did_cancel_all());
 }
 
-}  // namespace speech
+}  // namespace content