Listen for tab close notifications and cancel active speech sessions.

chrome/browser/speech/speech_input_bubble_controller_unittest.cc

 // Copyright (c) 2010 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/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/speech/speech_input_bubble_controller.h"
+#include "chrome/test/browser_with_test_window_test.h"
+#include "chrome/test/testing_profile.h"
 #include "gfx/rect.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class SkBitmap;
 
 namespace speech_input {
 
 // A mock bubble class which fakes a focus change or recognition cancel by the
 // user and closing of the info bubble.
 class MockSpeechInputBubble : public SpeechInputBubbleBase {
  public:
   enum BubbleType {
     BUBBLE_TEST_FOCUS_CHANGED,
     BUBBLE_TEST_CLICK_CANCEL,
     BUBBLE_TEST_CLICK_TRY_AGAIN,
   };
 
-  MockSpeechInputBubble(TabContents*, Delegate* delegate, const gfx::Rect&) {
+  MockSpeechInputBubble(TabContents* tab_contents,
+                        Delegate* delegate,
+                        const gfx::Rect&)
+      : SpeechInputBubbleBase(tab_contents) {
     VLOG(1) << "MockSpeechInputBubble created";
     MessageLoop::current()->PostTask(
         FROM_HERE, NewRunnableFunction(&InvokeDelegate, delegate));
   }
 
   static void InvokeDelegate(Delegate* delegate) {
     VLOG(1) << "MockSpeechInputBubble invoking delegate for type " << type_;
     switch (type_) {
       case BUBBLE_TEST_FOCUS_CHANGED:
         delegate->InfoBubbleFocusChanged();
@@ skipping 19 matching lines @@
   virtual void UpdateLayout() {}
   virtual void SetImage(const SkBitmap&) {}
 
  private:
   static BubbleType type_;
 };
 
 // The test fixture.
 class SpeechInputBubbleControllerTest
     : public SpeechInputBubbleControllerDelegate,
-      public testing::Test {
+      public BrowserWithTestWindowTest {
  public:
   SpeechInputBubbleControllerTest()
-      : io_loop_(MessageLoop::TYPE_IO),
-        ui_thread_(BrowserThread::UI),  // constructs a new thread and loop
-        io_thread_(BrowserThread::IO, &io_loop_),  // resuses main thread loop
+      : BrowserWithTestWindowTest(),
+        io_thread_(BrowserThread::IO),  // constructs a new thread and loop
         cancel_clicked_(false),
         try_again_clicked_(false),
         focus_changed_(false),
+        bubble_callback_event_(false, false),

[bulach, 2011/01/07 11:11:29]

I'm not very familiar, but seems that BrowserWithTestWindowTest provides access
to its ui message_loop(), so instead of signaling the event, you may just post a
quit task to it? would that work?

[Satish, 2011/01/07 11:19:15]

Done.

         controller_(ALLOW_THIS_IN_INITIALIZER_LIST(
             new SpeechInputBubbleController(this))) {
     EXPECT_EQ(NULL, test_fixture_);
     test_fixture_ = this;
   }
 
   ~SpeechInputBubbleControllerTest() {
     test_fixture_ = NULL;
   }
 
   // SpeechInputBubbleControllerDelegate methods.
   virtual void InfoBubbleButtonClicked(int caller_id,
                                        SpeechInputBubble::Button button) {
     VLOG(1) << "Received InfoBubbleButtonClicked for button " << button;
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     if (button == SpeechInputBubble::BUTTON_CANCEL) {
       cancel_clicked_ = true;
     } else if (button == SpeechInputBubble::BUTTON_TRY_AGAIN) {
       try_again_clicked_ = true;
     }
-    MessageLoop::current()->Quit();
+    bubble_callback_event_.Signal();
   }
 
   virtual void InfoBubbleFocusChanged(int caller_id) {
     VLOG(1) << "Received InfoBubbleFocusChanged";
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     focus_changed_ = true;
-    MessageLoop::current()->Quit();
+    bubble_callback_event_.Signal();
   }
 
   // testing::Test methods.
   virtual void SetUp() {
+    BrowserWithTestWindowTest::SetUp();
     SpeechInputBubble::set_factory(
         &SpeechInputBubbleControllerTest::CreateBubble);
-    ui_thread_.Start();
+    io_thread_.Start();
   }
 
   virtual void TearDown() {
     SpeechInputBubble::set_factory(NULL);
-    ui_thread_.Stop();
+    io_thread_.Stop();
+    BrowserWithTestWindowTest::TearDown();
   }
 
   static void ActivateBubble() {
     if (MockSpeechInputBubble::type() ==
         MockSpeechInputBubble::BUBBLE_TEST_FOCUS_CHANGED) {
       test_fixture_->controller_->SetBubbleRecordingMode(kBubbleCallerId);
     } else {
       test_fixture_->controller_->SetBubbleMessage(kBubbleCallerId,
                                                    ASCIIToUTF16("Test"));
     }
   }
 
   static SpeechInputBubble* CreateBubble(TabContents* tab_contents,
                                          SpeechInputBubble::Delegate* delegate,
                                          const gfx::Rect& element_rect) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
     // Set up to activate the bubble soon after it gets created, since we test
     // events sent by the bubble and those are handled only when the bubble is
     // active.
     MessageLoop::current()->PostTask(FROM_HERE,
                                      NewRunnableFunction(&ActivateBubble));
+
+    // The |tab_contents| parameter would be NULL since the dummy caller id
+    // passed to CreateBubble would not have matched any active tab. So get a
+    // real TabContents pointer from the test fixture and pass that, because
+    // the bubble controller registers for tab close notifications which need
+    // a valid TabContents.
+    tab_contents = test_fixture_->browser()->GetSelectedTabContents();
     return new MockSpeechInputBubble(tab_contents, delegate, element_rect);
   }
 
  protected:
   // The main thread of the test is marked as the IO thread and we create a new
   // one for the UI thread.
-  MessageLoop io_loop_;
-  BrowserThread ui_thread_;
   BrowserThread io_thread_;
   bool cancel_clicked_;
   bool try_again_clicked_;
   bool focus_changed_;
+  base::WaitableEvent bubble_callback_event_;
   scoped_refptr<SpeechInputBubbleController> controller_;
 
   static const int kBubbleCallerId;
   static SpeechInputBubbleControllerTest* test_fixture_;
 };
 
 SpeechInputBubbleControllerTest*
 SpeechInputBubbleControllerTest::test_fixture_ = NULL;
 
 const int SpeechInputBubbleControllerTest::kBubbleCallerId = 1;
 
 MockSpeechInputBubble::BubbleType MockSpeechInputBubble::type_ =
     MockSpeechInputBubble::BUBBLE_TEST_FOCUS_CHANGED;
 
 // Test that the speech bubble UI gets created in the UI thread and that the
 // focus changed callback comes back in the IO thread.
 TEST_F(SpeechInputBubbleControllerTest, TestFocusChanged) {
   MockSpeechInputBubble::set_type(
       MockSpeechInputBubble::BUBBLE_TEST_FOCUS_CHANGED);
 
   controller_->CreateBubble(kBubbleCallerId, 1, 1, gfx::Rect(1, 1));
-  MessageLoop::current()->Run();
+  MessageLoop::current()->RunAllPending();
+  bubble_callback_event_.Wait();
   EXPECT_TRUE(focus_changed_);
   EXPECT_FALSE(cancel_clicked_);
   EXPECT_FALSE(try_again_clicked_);
   controller_->CloseBubble(kBubbleCallerId);
 }
 
 // Test that the speech bubble UI gets created in the UI thread and that the
 // recognition cancelled callback comes back in the IO thread.
 TEST_F(SpeechInputBubbleControllerTest, TestRecognitionCancelled) {
   MockSpeechInputBubble::set_type(
       MockSpeechInputBubble::BUBBLE_TEST_CLICK_CANCEL);
 
   controller_->CreateBubble(kBubbleCallerId, 1, 1, gfx::Rect(1, 1));
-  MessageLoop::current()->Run();
+  MessageLoop::current()->RunAllPending();
+  bubble_callback_event_.Wait();
   EXPECT_TRUE(cancel_clicked_);
   EXPECT_FALSE(try_again_clicked_);
   EXPECT_FALSE(focus_changed_);
   controller_->CloseBubble(kBubbleCallerId);
 }
 
 // Test that the speech bubble UI gets created in the UI thread and that the
 // try-again button click event comes back in the IO thread.
 TEST_F(SpeechInputBubbleControllerTest, TestTryAgainClicked) {
   MockSpeechInputBubble::set_type(
       MockSpeechInputBubble::BUBBLE_TEST_CLICK_TRY_AGAIN);
 
   controller_->CreateBubble(kBubbleCallerId, 1, 1, gfx::Rect(1, 1));
-  MessageLoop::current()->Run();
+  MessageLoop::current()->RunAllPending();
+  bubble_callback_event_.Wait();
   EXPECT_FALSE(cancel_clicked_);
   EXPECT_TRUE(try_again_clicked_);
   EXPECT_FALSE(focus_changed_);
   controller_->CloseBubble(kBubbleCallerId);
 }
 
 }  // namespace speech_input