Update the Ready Mode UI in response to feedback from UI leads, Chrome Frame ...

chrome_frame/test/ready_mode_unittest.cc

 // Copyright (c) 2011 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 <atlbase.h>
 #include <atlapp.h>
 #include <atlmisc.h>
 #include <atlwin.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/win/registry.h"
 #include "chrome_frame/infobars/infobar_content.h"
 #include "chrome_frame/ready_mode/internal/ready_mode_state.h"
 #include "chrome_frame/ready_mode/internal/ready_prompt_content.h"
 #include "chrome_frame/ready_mode/internal/ready_prompt_window.h"
 #include "chrome_frame/ready_mode/internal/registry_ready_mode_state.h"
+#include "chrome_frame/ready_mode/internal/url_launcher.h"
 #include "chrome_frame/simple_resource_loader.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 
 namespace {
 
 class SetResourceInstance {
  public:
   SetResourceInstance() : res_dll_(NULL), old_res_dll_(NULL) {
     SimpleResourceLoader* loader_instance = SimpleResourceLoader::GetInstance();
     EXPECT_TRUE(loader_instance != NULL);
@@ skipping 59 matching lines @@
 };  // class Frame
 
 class MockReadyModeState : public ReadyModeState {
  public:
   // ReadyModeState implementation
   MOCK_METHOD0(TemporarilyDeclineChromeFrame, void(void));
   MOCK_METHOD0(PermanentlyDeclineChromeFrame, void(void));
   MOCK_METHOD0(AcceptChromeFrame, void(void));
 };  // class MockReadyModeState
 
+class MockUrlLauncher : public UrlLauncher {
+ public:
+  // UrlLauncher implementation
+  MOCK_METHOD1(LaunchUrl, void(const std::wstring& url));
+};  // class MockUrlLauncher
+
 }  // namespace
 
 class ReadyPromptTest : public testing::Test {
  public:
   ReadyPromptTest() : hwnd_(NULL) {}
 
   void SetUp() {
     hwnd_ = window_.Create(NULL);
     EXPECT_TRUE(hwnd_ != NULL);
     window_.ShowWindow(SW_SHOW);
     EXPECT_TRUE(window_.IsWindowVisible());
     EXPECT_CALL(frame_, GetFrameWindow()).Times(testing::AnyNumber())
         .WillRepeatedly(testing::Return(hwnd_));
   }
 
  protected:
   SimpleWindow window_;
   HWND hwnd_;
   MockInfobarContentFrame frame_;
   SetResourceInstance set_resource_instance_;
 };  // class ReadyPromptTest
 
 class ReadyPromptWindowTest : public ReadyPromptTest {
  public:
   void SetUp() {
     ReadyPromptTest::SetUp();
 
     // owned by ReadyPromptWindow
     state_ = new MockReadyModeState();
-    ready_prompt_window_ = (new ReadyPromptWindow())->Initialize(&frame_,
-                                                                 state_);
+    url_launcher_ = new MockUrlLauncher();
+
+    ready_prompt_window_ = ReadyPromptWindow::CreateInstance(
+        &frame_, state_, url_launcher_);
 
     ASSERT_TRUE(ready_prompt_window_ != NULL);
     RECT position = {0, 0, 800, 39};
     ASSERT_TRUE(ready_prompt_window_->SetWindowPos(HWND_TOP, &position,
                                                    SWP_SHOWWINDOW));
   }
 
  protected:
   MockReadyModeState* state_;
+  MockUrlLauncher* url_launcher_;
   base::WeakPtr<ReadyPromptWindow> ready_prompt_window_;
 };  // class ReadyPromptWindowTest
 
 class ReadyPromptWindowButtonTest : public ReadyPromptWindowTest {
  public:
   void TearDown() {
     ASSERT_TRUE(ready_prompt_window_ != NULL);
     ASSERT_TRUE(ready_prompt_window_->DestroyWindow());
     ASSERT_TRUE(ready_prompt_window_ == NULL);
     ASSERT_FALSE(message_loop_.WasTimedOut());
@@ skipping 55 matching lines @@
     EXPECT_CALL(frame_, CloseInfobar()).WillOnce(QUIT_LOOP(message_loop_));
     ASSERT_NO_FATAL_FAILURE(message_loop_.RunFor(5));  // seconds
   }
 
   chrome_frame_test::TimedMsgLoop message_loop_;
 };  // class ReadyPromptWindowButtonTest
 
 TEST_F(ReadyPromptTest, ReadyPromptContentTest) {
   // owned by ReadyPromptContent
   MockReadyModeState* state = new MockReadyModeState();
-  scoped_ptr<ReadyPromptContent> content_(new ReadyPromptContent(state));
+  MockUrlLauncher* url_launcher = new MockUrlLauncher();
+
+  scoped_ptr<ReadyPromptContent> content_(new ReadyPromptContent(state,
+                                                                 url_launcher));
 
   content_->InstallInFrame(&frame_);
 
   // Ensure that, if a child is created, it is not visible yet.
   HWND child_hwnd = window_.GetZeroOrOneChildWindows();
   if (child_hwnd != NULL) {
     CWindow child(child_hwnd);
     RECT child_dimensions;
     EXPECT_TRUE(child.GetClientRect(&child_dimensions));
     EXPECT_FALSE(child.IsWindowVisible() && !::IsRectEmpty(&child_dimensions));
@@ skipping 22 matching lines @@
   content_.reset();
 
   EXPECT_TRUE(window_.GetZeroOrOneChildWindows() == NULL);
 }
 
 TEST_F(ReadyPromptWindowTest, Destroy) {
   // Should delete associated mocks, not invoke on ReadyModeState
   ready_prompt_window_->DestroyWindow();
 }
 
-TEST_F(ReadyPromptWindowButtonTest, ClickYes) {
+TEST_F(ReadyPromptWindowButtonTest, ClickEnable) {
   EXPECT_CALL(*state_, AcceptChromeFrame());
-  ASSERT_TRUE(ClickOnCaption(L"&Yes"));
+  ASSERT_TRUE(ClickOnCaption(L"Enable"));
   RunUntilCloseInfobar();
 }
 
-TEST_F(ReadyPromptWindowButtonTest, ClickRemindMeLater) {
-  EXPECT_CALL(*state_, TemporarilyDeclineChromeFrame());
-  ASSERT_TRUE(ClickOnCaption(L"Remind me &Later"));
+TEST_F(ReadyPromptWindowButtonTest, ClickIgnore) {
+  EXPECT_CALL(*state_, PermanentlyDeclineChromeFrame());
+  ASSERT_TRUE(ClickOnCaption(L"Ignore"));
   RunUntilCloseInfobar();
 }
 
-TEST_F(ReadyPromptWindowButtonTest, ClickNo) {
-  EXPECT_CALL(*state_, PermanentlyDeclineChromeFrame());
-  ASSERT_TRUE(ClickOnCaption(L"&No"));
-  RunUntilCloseInfobar();
-}
-
 // TODO(erikwright): test WebBrowserAdapter
 // TODO(erikwright): an integration test of ReadyMode::Configure with a mock
 //                   IWebBrowser2?