Added unit tests for ChromeFrame IE full tab mode. These test the following c...

chrome_frame/test/chrome_frame_unittests.cc

 // Copyright (c) 2006-2008 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 <windows.h>
 #include <stdarg.h>
 
 // IShellWindows includes.  Unfortunately we can't keep these in
 // alphabetic order since exdisp will bark if some interfaces aren't fully
 // defined.
 #include <mshtml.h>
 #include <exdisp.h>
 
 #include "base/basictypes.h"
 #include "base/file_version_info.h"
 #include "base/file_util.h"
 #include "base/scoped_bstr_win.h"
-#include "base/scoped_comptr_win.h"
 #include "base/scoped_variant_win.h"
 #include "base/sys_info.h"
 #include "gmock/gmock.h"
 #include "net/url_request/url_request_unittest.h"
 #include "chrome_frame/test/chrome_frame_unittests.h"
 #include "chrome_frame/chrome_frame_automation.h"
 #include "chrome_frame/chrome_frame_delegate.h"
 #include "chrome_frame/crash_reporting/vectored_handler-impl.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test_utils.h"
@@ skipping 29 matching lines @@
     VT_DISPATCH,
     VT_VARIANT | VT_BYREF,
     VT_VARIANT | VT_BYREF,
     VT_VARIANT | VT_BYREF,
     VT_VARIANT | VT_BYREF,
     VT_VARIANT | VT_BYREF,
     VT_BOOL | VT_BYREF
   }
 };
 
+_ATL_FUNC_INFO WebBrowserEventSink::kNewWindow3Info = {
+  CC_STDCALL, VT_EMPTY, 5, {
+    VT_DISPATCH | VT_BYREF,
+    VT_BOOL | VT_BYREF,
+    VT_UINT,
+    VT_BSTR,
+    VT_BSTR
+  }
+};
+
 
-
 void ChromeFrameTestWithWebServer::SetUp() {
   server_.SetUp();
   results_dir_ = server_.GetDataDir();
   file_util::AppendToPath(&results_dir_, L"dump");
 }
 
 void ChromeFrameTestWithWebServer::TearDown() {
   CloseBrowser();
 
   // Web browsers tend to relaunch themselves in other processes, meaning the
@@ skipping 744 matching lines @@
 template <> struct RunnableMethodTraits<ChromeFrameAutomationClient> {
   void RetainCallee(ChromeFrameAutomationClient* obj) {}
   void ReleaseCallee(ChromeFrameAutomationClient* obj) {}
 };
 
 // MessageLoopForUI wrapper that runs only for a limited time.
 // We need a UI message loop in the main thread.
 struct TimedMsgLoop {
  public:
   void RunFor(int seconds) {
-    loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask, 1000 * seconds);
+    QuitAfter(seconds);
     loop_.MessageLoop::Run();
   }
 
   void Quit() {
     loop_.PostTask(FROM_HERE, new MessageLoop::QuitTask);
   }
 
+  void QuitAfter(int seconds) {
+    loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask, 1000 * seconds);
+  }
+
   MessageLoopForUI loop_;
 };
 
 template <> struct RunnableMethodTraits<TimedMsgLoop> {
   void RetainCallee(TimedMsgLoop* obj) {}
   void ReleaseCallee(TimedMsgLoop* obj) {}
 };
 
 // Saves typing. It's somewhat hard to create a wrapper around
 // testing::InvokeWithoutArgs since it returns a
 // non-public (testing::internal) type.
 #define QUIT_LOOP(loop) testing::InvokeWithoutArgs(\
     CreateFunctor(&loop, &TimedMsgLoop::Quit))
 
+#define QUIT_LOOP_SOON(loop, seconds) testing::InvokeWithoutArgs(\
+    CreateFunctor(&loop, &TimedMsgLoop::QuitAfter, seconds))
+
 // We mock ChromeFrameDelegate only. The rest is with real AutomationProxy
 TEST(CFACWithChrome, CreateTooFast) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   int timeout = 0;  // Chrome cannot send Hello message so fast.
   const std::wstring profile = L"Adam.N.Epilinter";
 
   scoped_ptr<ChromeFrameAutomationClient> client;
   client.reset(new ChromeFrameAutomationClient());
 
@@ skipping 408 matching lines @@
       CLSID_InternetExplorer, NULL, CLSCTX_LOCAL_SERVER, IID_IWebBrowser2,
       reinterpret_cast<void**>(web_browser2.Receive()));
 
   if (SUCCEEDED(hr)) {
     *web_browser = web_browser2.Detach();
   }
 
   return hr;
 }
 
-TEST(ChromeFrameTest, FullTabModeIE_DisallowedUrls) {
+// WebBrowserEventSink member defines
+HRESULT WebBrowserEventSink::LaunchIEAndNavigate(
+    const std::wstring& navigate_url, _IDispEvent* sink) {
   int major_version = 0;
   int minor_version = 0;
   int bugfix_version = 0;
 
   base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
                                                &bugfix_version);
   if (major_version > 5) {
     DLOG(INFO) << __FUNCTION__ << " Not running test on Windows version: "
                << major_version;
-    return;
+    return S_FALSE;
   }
 
   IEVersion ie_version = GetIEVersion();
   if (ie_version == IE_8) {
     DLOG(INFO) << __FUNCTION__ << " Not running test on IE8";
-    return;
+    return S_FALSE;
   }
 
-  HRESULT hr = CoInitialize(NULL);
-  bool should_uninit = SUCCEEDED(hr);
-
-  ScopedComPtr<IWebBrowser2> web_browser2;
-  EXPECT_TRUE(S_OK == LaunchIEAsComServer(web_browser2.Receive()));
-  web_browser2->put_Visible(VARIANT_TRUE);
-
-  CComObject<WebBrowserEventSink>* web_browser_sink = NULL;
-  CComObject<WebBrowserEventSink>::CreateInstance(&web_browser_sink);
-
-  // Pass the main thread id to the browser sink so that it can notify
-  // us about test completion.
-  web_browser_sink->set_main_thread_id(GetCurrentThreadId());
-
-  hr = web_browser_sink->DispEventAdvise(web_browser2,
-                                         &DIID_DWebBrowserEvents2);
+  EXPECT_TRUE(S_OK == LaunchIEAsComServer(web_browser2_.Receive()));
+  web_browser2_->put_Visible(VARIANT_TRUE);
+
+  HRESULT hr = sink->DispEventAdvise(web_browser2_,
+                                     &DIID_DWebBrowserEvents2);
   EXPECT_TRUE(hr == S_OK);
 
   VARIANT empty = ScopedVariant::kEmptyVariant;
   ScopedVariant url;
-  url.Set(L"cf:file:///C:/");
-
+  url.Set(navigate_url.c_str());
+
+  hr = web_browser2_->Navigate2(url.AsInput(), &empty, &empty, &empty, &empty);
+  EXPECT_TRUE(hr == S_OK);
+  return hr;
+}
+
+const int kChromeFrameLongNavigationTimeoutInSeconds = 10;
+
+// This class provides functionality to add expectations to IE full tab mode
+// tests.
+class MockWebBrowserEventSink : public WebBrowserEventSink {
+ public:
+  // Needed to support PostTask.
+  static bool ImplementsThreadSafeReferenceCounting() {
+    return true;
+  }
+
+  MOCK_METHOD7_WITH_CALLTYPE(__stdcall, OnBeforeNavigate2,
+                             HRESULT (IDispatch* dispatch,
+                                      VARIANT* url,
+                                      VARIANT* flags,
+                                      VARIANT* target_frame_name,
+                                      VARIANT* post_data,
+                                      VARIANT* headers,
+                                      VARIANT_BOOL* cancel));
+
+  MOCK_METHOD2_WITH_CALLTYPE(__stdcall, OnNavigateComplete2,
+                             void (IDispatch* dispatch, VARIANT* url));
+
+  MOCK_METHOD5_WITH_CALLTYPE(__stdcall, OnNewWindow3,
+                             void (IDispatch** dispatch,
+                                   VARIANT_BOOL* Cancel,
+                                   DWORD flags,
+                                   BSTR url_context,
+                                   BSTR url));
+
+  MOCK_METHOD5_WITH_CALLTYPE(__stdcall, OnNavigateError,
+                             void (IDispatch* dispatch,
+                                   VARIANT* url,
+                                   VARIANT* frame_name,
+                                   VARIANT* status_code,
+                                   VARIANT* cancel));
+};
+
+using testing::_;
+
+const wchar_t kChromeFrameFileUrl[] = L"cf:file:///C:/";
+
+TEST(ChromeFrameTest, FullTabModeIE_DisallowedUrls) {
   TimedMsgLoop loop;
-
-  hr = web_browser2->Navigate2(url.AsInput(), &empty, &empty, &empty, &empty);
-  EXPECT_TRUE(hr == S_OK);
-
-  loop.RunFor(10);
-
-  EXPECT_TRUE(web_browser_sink->navigation_failed());
-
-  hr = web_browser_sink->DispEventUnadvise(web_browser2);
-  EXPECT_TRUE(hr == S_OK);
-
-  web_browser2.Release();
+  // If a navigation fails then IE issues a navigation to an interstitial
+  // page. Catch this to track navigation errors as the NavigateError
+  // notification does not seem to fire reliably.
+  CComObjectStackEx<MockWebBrowserEventSink> mock;
+
+  EXPECT_CALL(mock,
+              OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                testing::StrCaseEq(kChromeFrameFileUrl)),
+                                _, _, _, _, _))
+      .Times(1)
+      .WillOnce(testing::Return(S_OK));
+
+  EXPECT_CALL(mock,
+              OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                testing::StartsWith(L"res:")),
+                                _, _, _, _, _))
+      .Times(1)
+      .WillOnce(testing::DoAll(
+          QUIT_LOOP(loop),
+          testing::Return(S_OK)));
+
+  HRESULT hr = mock.LaunchIEAndNavigate(kChromeFrameFileUrl, &mock);
+  ASSERT_HRESULT_SUCCEEDED(hr);
+  if (hr == S_FALSE)
+    return;
+
+  ASSERT_TRUE(mock.web_browser2() != NULL);
+
+  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+
+  mock.Uninitialize();
   chrome_frame_test::CloseAllIEWindows();
-
-  if (should_uninit) {
-    CoUninitialize();
-  }
-}
-
+}
+
+const wchar_t kChromeFrameFullTabWindowOpenTestUrl[] =
+    L"http://localhost:1337/files/chrome_frame_window_open.html";
+
+const wchar_t kChromeFrameFullTabWindowOpenPopupUrl[] =
+    L"http://localhost:1337/files/chrome_frame_window_open_popup.html";
+
+// This test checks if window.open calls issued by a full tab mode ChromeFrame
+// instance make it back to IE and then transitions back to Chrome as the
+// window.open target page is supposed to render within Chrome.
+TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_WindowOpen) {
+  TimedMsgLoop loop;
+
+  CComObjectStackEx<MockWebBrowserEventSink> mock;
+
+  EXPECT_CALL(mock,
+              OnBeforeNavigate2(
+                  _, testing::Field(&VARIANT::bstrVal,
+                  testing::StrCaseEq(kChromeFrameFullTabWindowOpenTestUrl)),
+                  _, _, _, _, _))
+      .Times(1)
+      .WillOnce(testing::Return(S_OK));
+
+  EXPECT_CALL(mock,
+              OnBeforeNavigate2(
+                  _, testing::Field(&VARIANT::bstrVal,
+                  testing::StrCaseEq(kChromeFrameFullTabWindowOpenPopupUrl)),
+                  _, _, _, _, _))
+      .Times(1)
+      .WillOnce(testing::DoAll(
+          QUIT_LOOP_SOON(loop, 2),
+          testing::Return(S_OK)));
+
+  HRESULT hr = mock.LaunchIEAndNavigate(kChromeFrameFullTabWindowOpenTestUrl,
+                                        &mock);
+  ASSERT_HRESULT_SUCCEEDED(hr);
+  if (hr == S_FALSE)
+    return;
+
+  ASSERT_TRUE(mock.web_browser2() != NULL);
+
+  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+
+  ASSERT_TRUE(CheckResultFile(L"ChromeFrameWindowOpenPopup", "OK"));
+
+  mock.Uninitialize();
+  chrome_frame_test::CloseAllIEWindows();
+}
+
+const wchar_t kChromeFrameAboutBlankUrl[] =
+    L"cf:about:blank";
+
+const wchar_t kChromeFrameAboutVersion[] =
+    L"cf:about:version";
+
+// This test launches chrome frame in full tab mode in IE by having IE navigate
+// to cf:about:blank. It then looks for the chrome renderer window and posts
+// the WM_RBUTTONDOWN/WM_RBUTTONUP messages to it, which bring up the context
+// menu. This is followed by keyboard messages sent via SendInput to select
+// the About chrome frame menu option, which would then bring up a new window
+// with the chrome revision. The test finally checks for success by comparing
+// the URL of the window being opened with cf:about:version, which indicates
+// that the operation succeeded.
+TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_AboutChromeFrame) {
+  TimedMsgLoop loop;
+
+  CComObjectStackEx<MockWebBrowserEventSink> mock;
+
+  EXPECT_CALL(mock,
+              OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                testing::StrCaseEq(kChromeFrameAboutBlankUrl)),
+                                _, _, _, _, _))
+      .Times(1)
+      .WillOnce(testing::Return(S_OK));
+
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .Times(1)
+      .WillOnce(testing::InvokeWithoutArgs(
+          &chrome_frame_test::ShowChromeFrameContextMenu));
+
+  EXPECT_CALL(mock,
+              OnNewWindow3(_, _, _, _,
+                           testing::StrCaseEq(kChromeFrameAboutVersion)))
+      .Times(1)
+      .WillOnce(QUIT_LOOP(loop));
+
+  HRESULT hr = mock.LaunchIEAndNavigate(kChromeFrameAboutBlankUrl, &mock);
+  ASSERT_HRESULT_SUCCEEDED(hr);
+  if (hr == S_FALSE)
+    return;
+
+  ASSERT_TRUE(mock.web_browser2() != NULL);
+
+  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+
+  mock.Uninitialize();
+  chrome_frame_test::CloseAllIEWindows();
+}
+