Refactoring of chrome speech recognition architecture (CL1.6)

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/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
@@ skipping 17 matching lines @@
 class FakeSpeechRecognitionManager;
 }
 
 namespace speech {
 
 const char kTestResult[] = "Pictures of the moon";
 
 class FakeSpeechRecognitionManager : public SpeechRecognitionManagerImpl {
  public:
   FakeSpeechRecognitionManager()
-      : caller_id_(0),
+      : session_id_(0),
         delegate_(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 caller_id,
+      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.";
-    EXPECT_EQ(0, caller_id_);
+    EXPECT_EQ(0, session_id_);
     EXPECT_EQ(NULL, delegate_);
-    caller_id_ = caller_id;
+    session_id_ = session_id;
     delegate_ = delegate;
     grammar_ = grammar;
     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 caller_id) OVERRIDE {
+  virtual void CancelRecognition(int session_id) OVERRIDE {
     VLOG(1) << "CancelRecognition invoked.";
-    EXPECT_EQ(caller_id_, caller_id);
-    caller_id_ = 0;
+    EXPECT_EQ(session_id_, session_id);
+    session_id_ = 0;
     delegate_ = NULL;
   }
-  virtual void StopRecording(int caller_id) OVERRIDE {
+  virtual void StopRecording(int session_id) OVERRIDE {
     VLOG(1) << "StopRecording invoked.";
-    EXPECT_EQ(caller_id_, caller_id);
+    EXPECT_EQ(session_id_, session_id);
     // Nothing to do here since we aren't really recording.
   }
   virtual void CancelAllRequestsWithDelegate(
       InputTagSpeechDispatcherHost* delegate) 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
     // no fake result sent.
     EXPECT_TRUE(should_send_fake_response_ || delegate_ == delegate);
     did_cancel_all_ = true;
   }
 
  private:
   void SetFakeRecognitionResult() {
-    if (caller_id_) {  // Do a check in case we were cancelled..
+    if (session_id_) {  // Do a check in case we were cancelled..
       VLOG(1) << "Setting fake recognition result.";
-      delegate_->DidCompleteRecording(caller_id_);
+      delegate_->DidCompleteRecording(session_id_);
       content::SpeechRecognitionResult results;
       results.hypotheses.push_back(content::SpeechRecognitionHypothesis(
           ASCIIToUTF16(kTestResult), 1.0));
-      delegate_->SetRecognitionResult(caller_id_, results);
-      delegate_->DidCompleteRecognition(caller_id_);
-      caller_id_ = 0;
+      delegate_->SetRecognitionResult(session_id_, results);
+      delegate_->DidCompleteRecognition(session_id_);
+      session_id_ = 0;
       delegate_ = NULL;
       VLOG(1) << "Finished setting fake recognition result.";
     }
   }
 
-  int caller_id_;
+  int session_id_;
   InputTagSpeechDispatcherHost* delegate_;
   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 102 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