[chrome_frame] Refactor/merge IE no interference tests with other mock event ...

chrome_frame/test/navigation_test.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 <string>
+
+#include "base/scoped_comptr_win.h"
+#include "base/win_util.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
+#include "chrome_frame/test/mock_ie_event_sink_actions.h"
+#include "chrome_frame/test/mock_ie_event_sink_test.h"
+
+// Needed for CreateFunctor.
+#define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
+#include "testing/gmock_mutant.h"
+
+using testing::_;
+using testing::InSequence;
+using testing::StrEq;
+
+namespace chrome_frame_test {
+
+const wchar_t tab_enter_keys[] = { VK_TAB, VK_RETURN, 0 };
+
+// Test fixture for navigation-related tests. Each test is run thrice: IE, CF
+// with meta tag invocation, and CF with http header invocation. This is
+// accomplished by using gTest's parameterized test.
+class FullTabNavigationTest
+    : public MockIEEventSinkTest, public testing::TestWithParam<CFInvocation> {
+ public:
+  FullTabNavigationTest() {}
+};
+
+// Instantiate each test case. Instead of doing in one statement, it is split
+// into three so gTest prints nicer names.
+INSTANTIATE_TEST_CASE_P(IE, FullTabNavigationTest, testing::Values(
+    CFInvocation(CFInvocation::NONE)));
+INSTANTIATE_TEST_CASE_P(MetaTag, FullTabNavigationTest, testing::Values(
+    CFInvocation(CFInvocation::META_TAG)));
+INSTANTIATE_TEST_CASE_P(HttpHeader, FullTabNavigationTest, testing::Values(
+    CFInvocation(CFInvocation::HTTP_HEADER)));
+
+// This tests navigation to a typed URL.
+TEST_P(FullTabNavigationTest, FLAKY_TypeUrl) {
+  ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl());
+  server_mock_.ExpectAndServeRequest(CFInvocation::None(), GetSimplePageUrl());
+  EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl())))
+      .WillOnce(testing::DoAll(
+          SetFocusToRenderer(&ie_mock_),
+          TypeUrlInAddressBar(&loop_, GetAnchorPageUrl(0), 1500)));
+
+  bool in_cf = GetParam().invokes_cf();
+  ie_mock_.ExpectNavigation(in_cf, GetAnchorPageUrl(0));
+  server_mock_.ExpectAndServeRequest(GetParam(), GetAnchorPageUrl(0));
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(0))))
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(GetSimplePageUrl());
+}
+
+// This tests navigation to a typed URL containing an anchor/fragment.
+TEST_P(FullTabNavigationTest, FLAKY_TypeAnchorUrl) {
+  if (IsIBrowserServicePatchEnabled()) {
+    LOG(ERROR) << "Not running test. IBrowserServicePatch is in place.";
+    return;
+  }
+
+  ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl());
+  server_mock_.ExpectAndServeRequest(CFInvocation::None(), GetSimplePageUrl());
+  EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl())))
+      .WillOnce(testing::DoAll(
+          SetFocusToRenderer(&ie_mock_),
+          TypeUrlInAddressBar(&loop_, GetAnchorPageUrl(1), 1500)));
+
+  bool in_cf = GetParam().invokes_cf();
+  ie_mock_.ExpectNavigation(in_cf, GetAnchorPageUrl(1));
+  server_mock_.ExpectAndServeRequest(GetParam(), GetAnchorPageUrl(1));
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(1))))
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(GetSimplePageUrl());
+}
+
+// Tests refreshing when no cached copy is available.
+TEST_P(FullTabNavigationTest, FLAKY_RefreshNoCachedCopy) {
+  bool in_cf = GetParam().invokes_cf();
+  // Unfortunately it is difficult to verify that both the IE events and
+  // the server requests are correct if the test is in sequence like this one.
+  // This is because the server request happens sometime in the middle of the
+  // IE events. Therefore we will just use the server events for this one.
+  ie_mock_.ExpectAnyNavigations();
+  // This test needs to be in sequence because we are expecting the same events.
+  InSequence expect_in_scope_for_sequence;
+
+  testing::Cardinality initial_req_cardinality = testing::Exactly(1);
+  // TODO(kkania): Remove this allowance for double request on meta tag when no
+  // longer necessary.
+  if (GetParam().type() == CFInvocation::META_TAG)
+    initial_req_cardinality = testing::Between(1, 2);
+  EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
+      .Times(initial_req_cardinality)
+      .WillRepeatedly(SendResponse(&server_mock_, GetParam()));
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl())))
+      .WillOnce(testing::DoAll(
+          SetFocusToRenderer(&ie_mock_),
+          DelayRefresh(&ie_mock_, &loop_, 0)));
+
+  if (in_cf) {
+    server_mock_.ExpectAndServeRequest(GetParam(), GetSimplePageUrl());
+    EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl())))
+        .WillOnce(testing::DoAll(
+            VerifyAddressBarUrl(&ie_mock_),
+            CloseBrowserMock(&ie_mock_)));
+  } else {
+    EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
+        .WillOnce(CloseBrowserMock(&ie_mock_));
+    // For some reason IE does not trigger another load after this refresh.
+  }
+
+  LaunchIENavigateAndLoop(GetSimplePageUrl(), 5);
+}
+
+// Tests refreshing when a cached copy is available.
+TEST_P(FullTabNavigationTest, FLAKY_RefreshWithCachedCopy) {
+  bool in_cf = GetParam().invokes_cf();
+  ie_mock_.ExpectAnyNavigations();
+  InSequence expect_in_scope_for_sequence;
+
+  testing::Cardinality initial_req_cardinality = testing::Exactly(1);
+  // TODO(kkania): Remove this allowance for double request on meta tag when no
+  // longer necessary.
+  if (GetParam().type() == CFInvocation::META_TAG)
+    initial_req_cardinality = testing::Between(1, 2);
+  EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
+      .Times(initial_req_cardinality)
+      .WillRepeatedly(SendAllowCacheResponse(&server_mock_, GetParam()));
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl())))
+        .WillOnce(testing::DoAll(
+            SetFocusToRenderer(&ie_mock_),
+            DelayRefresh(&ie_mock_, &loop_, 0)));
+
+  if (in_cf) {
+    // For some reason IE7 requests the resource again.
+    if (GetInstalledIEVersion() == IE_7) {
+      server_mock_.ExpectAndServeRequest(GetParam(), GetSimplePageUrl());
+    }
+    EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl())))
+        .WillOnce(testing::DoAll(
+            SetFocusToRenderer(&ie_mock_),
+            CloseBrowserMock(&ie_mock_)));
+  } else {
+    // For some reason IE still requests the resource again, but does not
+    // trigger another load.
+    EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
+        .WillOnce(CloseBrowserMock(&ie_mock_));
+  }
+
+  LaunchIEAndNavigate(GetSimplePageUrl());
+}
+
+// Test that multiple back and forward requests work.
+TEST_P(FullTabNavigationTest, MultipleBackForward) {
+  std::wstring page1 = GetSimplePageUrl();
+  std::wstring page2 = GetLinkPageUrl();
+  std::wstring page3 = GetAnchorPageUrl(0);
+  bool in_cf = GetParam().invokes_cf();
+  server_mock_.ExpectAndServeAnyRequests(GetParam());
+  InSequence expect_in_sequence_for_scope;
+
+  // Navigate to url 2 after the previous navigation is complete.
+  ie_mock_.ExpectNavigation(in_cf, page1);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          Navigate(&ie_mock_, page2)));
+
+  // Navigate to url 3 after the previous navigation is complete.
+  ie_mock_.ExpectNavigation(in_cf, page2);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          Navigate(&ie_mock_, page3)));
+
+  // We have reached url 3 and have two back entries for url 1 & 2.
+  // Go back to url 2 now.
+  ie_mock_.ExpectNavigation(in_cf, page3);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page3)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoBack(&ie_mock_, &loop_, 0)));
+
+  // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3.
+  // Go back to url 1 now.
+  ie_mock_.ExpectNavigation(in_cf, page2);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoBack(&ie_mock_, &loop_, 0)));
+
+  // We have reached url 1 and have 0 back & 2 forward entries for url 2 & 3.
+  // Go forward to url 2 now.
+  ie_mock_.ExpectNavigation(in_cf, page1);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoForward(&ie_mock_, &loop_, 0)));
+
+  // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3.
+  // Go forward to url 3 now.
+  ie_mock_.ExpectNavigation(in_cf, page2);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoForward(&ie_mock_, &loop_, 0)));
+
+  // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3.
+  ie_mock_.ExpectNavigation(in_cf, page3);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page3)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          CloseBrowserMock(&ie_mock_)));
+
+  LaunchIEAndNavigate(page1);
+}
+
+// Test multiple back and forward operations among urls with anchors.
+// Marking this test FLAKY as it fails at times on the buildbot.
+// http://code.google.com/p/chromium/issues/detail?id=26549
+TEST_P(FullTabNavigationTest, FLAKY_BackForwardAnchor) {
+  if (!GetParam().invokes_cf()) {
+    DLOG(ERROR) << "Test not implemented yet for IE.";
+    return;
+  }
+  std::wstring kAnchorUrl = GetTestUrl(L"anchor.html");
+  std::wstring kAnchor1Url = GetTestUrl(L"anchor.html#a1");
+  std::wstring kAnchor2Url = GetTestUrl(L"anchor.html#a2");
+  std::wstring kAnchor3Url = GetTestUrl(L"anchor.html#a3");
+  bool in_cf = GetParam().invokes_cf();
+  server_mock_.ExpectAndServeAnyRequests(GetParam());
+  InSequence expect_in_sequence_for_scope;
+
+  // Navigate to anchor 1:
+  // - First set focus to chrome renderer window
+  //   Call WebBrowserEventSink::SetFocusToRenderer only once
+  //   in the beginning. Calling it again will change focus from the
+  //   current location to an element near the simulated mouse click.
+  // - Then send keyboard input of TAB + ENTER to cause navigation.
+  //   It's better to send input as PostDelayedTask since the Activex
+  //   message loop_ on the other side might be blocked when we get
+  //   called in Onload.
+  // Back/Forward state at this point:
+  // Back: 0
+  // Forward: 0
+  ie_mock_.ExpectNavigation(in_cf, kAnchorUrl);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchorUrl)))
+      .WillOnce(testing::DoAll(
+          SetFocusToRenderer(&ie_mock_),
+          DelaySendString(&loop_, 500, tab_enter_keys)));
+
+  // Navigate to anchor 2 after the previous navigation is complete
+  // Back/Forward state at this point:
+  // Back: 1 (kAnchorUrl)
+  // Forward: 0
+  ie_mock_.ExpectAnchorNavigation(in_cf, kAnchor1Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor1Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelaySendString(&loop_, 500, tab_enter_keys)));
+
+  // Navigate to anchor 3 after the previous navigation is complete
+  // Back/Forward state at this point:
+  // Back: 2 (kAnchorUrl, kAnchor1Url)
+  // Forward: 0
+  ie_mock_.ExpectAnchorNavigation(in_cf, kAnchor2Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor2Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelaySendString(&loop_, 500, tab_enter_keys)));
+
+  // We will reach anchor 3 once the navigation is complete,
+  // then go back to anchor 2
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 0
+  ie_mock_.ExpectAnchorNavigation(in_cf, kAnchor3Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor3Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoBack(&ie_mock_, &loop_, 0)));
+
+  // We will reach anchor 2 once the navigation is complete,
+  // then go back to anchor 1
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 1 (kAnchor3Url)
+  ie_mock_.ExpectNavigation(in_cf, kAnchor2Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor2Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoBack(&ie_mock_, &loop_, 0)));
+
+  // We will reach anchor 1 once the navigation is complete,
+  // now go forward to anchor 2
+  // Back/Forward state at this point:
+  // Back: 2 (kAnchorUrl, kAnchor1Url)
+  // Forward: 2 (kAnchor2Url, kAnchor3Url)
+  ie_mock_.ExpectNavigation(in_cf, kAnchor1Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor1Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoForward(&ie_mock_, &loop_, 0)));
+
+  // We have reached anchor 2, go forward to anchor 3 again
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 1 (kAnchor3Url)
+  ie_mock_.ExpectNavigation(in_cf, kAnchor2Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor2Url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          DelayGoForward(&ie_mock_, &loop_, 0)));
+
+  // We have gone a few steps back and forward, this should be enough for now.
+  ie_mock_.ExpectNavigation(in_cf, kAnchor3Url);
+  EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kAnchor3Url)))
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(kAnchorUrl);
+}
+
+// Test that a user cannot navigate to a restricted site and that the security
+// dialog appears.
+TEST_P(FullTabNavigationTest, FLAKY_RestrictedSite) {
+  if (!GetParam().invokes_cf())
+    return;
+  if (IsIBrowserServicePatchEnabled()) {
+    LOG(ERROR) << "Not running test. IBrowserServicePatch is in place.";
+    return;
+  }
+  MockWindowObserver win_observer_mock;
+  ScopedComPtr<IInternetSecurityManager> security_manager;
+  HRESULT hr = security_manager.CreateInstance(CLSID_InternetSecurityManager);
+  ASSERT_HRESULT_SUCCEEDED(hr);
+  // Add the server to restricted sites zone.
+  hr = security_manager->SetZoneMapping(URLZONE_UNTRUSTED,
+      GetTestUrl(L"").c_str(), SZM_CREATE);
+
+  EXPECT_CALL(ie_mock_, OnFileDownload(_, _))
+      .Times(testing::AnyNumber());
+  server_mock_.ExpectAndServeAnyRequests(GetParam());
+
+  ProtocolPatchMethod patch_method = GetPatchMethod();
+
+  const wchar_t* kDialogClass = L"#32770";
+  const char* kAlertDlgCaption = "Security Alert";
+
+  EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_,
+      testing::Field(&VARIANT::bstrVal,
+      testing::StrCaseEq(GetSimplePageUrl())), _, _, _, _, _))
+      .Times(1)
+      .WillOnce(WatchWindow(&win_observer_mock, kDialogClass));
+
+  if (patch_method == PATCH_METHOD_INET_PROTOCOL) {
+    EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_,
+        testing::Field(&VARIANT::bstrVal,
+        testing::HasSubstr(L"res://")), _, _, _, _, _))
+        .Times(testing::AtMost(1));
+  }
+
+  EXPECT_CALL(ie_mock_, OnNavigateComplete2(_,
+      testing::Field(&VARIANT::bstrVal, StrEq(GetSimplePageUrl()))))
+      .Times(testing::AtMost(1));
+
+  EXPECT_CALL(win_observer_mock, OnWindowDetected(_, StrEq(kAlertDlgCaption)))
+      .Times(1)
+      .WillOnce(testing::DoAll(
+          DoCloseWindow(),
+          CloseBrowserMock(&ie_mock_)));
+
+  LaunchIEAndNavigate(GetSimplePageUrl());
+
+  ASSERT_HRESULT_SUCCEEDED(security_manager->SetZoneMapping(URLZONE_UNTRUSTED,
+      GetTestUrl(L"").c_str(), SZM_DELETE));
+}
+
+// This test checks if window.open calls with target blank issued for a
+// different domain make it back to IE instead of completing the navigation
+// within Chrome. We validate this by initiating a navigation to a non existent
+// url which ensures we would get an error during navigation.
+// Marking this test as FLAKY initially as it relies on getting focus and user
+// input which don't work correctly at times.
+// http://code.google.com/p/chromium/issues/detail?id=26549
+TEST_P(FullTabNavigationTest, FLAKY_JavascriptWindowOpenDifferentDomain) {
+  std::wstring parent_url =
+      GetTestUrl(L"window_open.html?http://www.nonexistent.com");
+  MockIEEventSink new_window_mock;
+  ie_mock_.ExpectAnyNavigations();
+  new_window_mock.ExpectAnyNavigations();
+  server_mock_.ExpectAndServeAnyRequests(GetParam());
+
+  EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(), StrEq(parent_url)))
+      .WillOnce(DelaySendDoubleClick(&ie_mock_, &loop_, 0, 10, 10));
+
+  ie_mock_.ExpectNewWindow(&new_window_mock);
+
+  EXPECT_CALL(new_window_mock, OnNavigateError(_, _, _, _, _))
+      .Times(1)
+      .WillOnce(CloseBrowserMock(&new_window_mock));
+
+  EXPECT_CALL(new_window_mock, OnQuit())
+      .Times(1)
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  // OnNavigateError can take a long time to fire.
+  LaunchIENavigateAndLoop(parent_url,
+                          kChromeFrameLongNavigationTimeoutInSeconds * 4);
+  ASSERT_TRUE(new_window_mock.event_sink()->web_browser2() != NULL);
+}
+
+// Tests that a page that calls window.open can then close the popup.
+// Marking this test as FLAKY initially as it relies on getting focus and user
+// input which don't work correctly at times.
+// http://code.google.com/p/chromium/issues/detail?id=26549
+TEST_P(FullTabNavigationTest, FLAKY_JavascriptWindowOpenCanClose) {
+  std::wstring parent_url =
+      GetTestUrl(L"window_open.html?simple.html");
+  MockIEEventSink new_window_mock;
+  ie_mock_.ExpectAnyNavigations();
+  new_window_mock.ExpectAnyNavigations();
+  server_mock_.ExpectAndServeAnyRequests(GetParam());
+
+  // Sending 'A' to the renderer should cause window.open then window.close.
+  EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(), StrEq(parent_url)))
+      .WillOnce(DelaySendDoubleClick(&ie_mock_, &loop_, 0, 10, 10));
+
+  ie_mock_.ExpectNewWindow(&new_window_mock);
+
+  EXPECT_CALL(new_window_mock, OnLoad(_, StrEq(GetSimplePageUrl())))
+      .Times(testing::AtMost(2))
+      .WillOnce(testing::DoAll(
+          SetFocusToRenderer(&ie_mock_),
+          DelaySendChar(&loop_, 500, 'C', simulate_input::NONE)))
+      .WillOnce(testing::Return());  // just to stop a gmock warning
+
+  EXPECT_CALL(new_window_mock, OnQuit())
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(parent_url);
+}
+
+// Parameter for tests using the NavigationTransitionTest fixture. Includes two
+// pages, each with their own possible CF invocation.
+struct NavigationTransitionTestParameter {
+  NavigationTransitionTestParameter(CFInvocation::Type type1,
+                                    CFInvocation::Type type2) {
+    page1_ = CFInvocation(type1);
+    page2_ = CFInvocation(type2);
+  }
+  CFInvocation page1_;
+  CFInvocation page2_;
+};
+
+// Parameterized test fixture for tests which test navigation transitions
+// between two pages.
+class NavigationTransitionTest
+    : public MockIEEventSinkTest,
+      public testing::TestWithParam<NavigationTransitionTestParameter> {
+ public:
+  NavigationTransitionTest() {}
+
+  virtual void SetUp() {
+    page1_ = GetParam().page1_;
+    page2_ = GetParam().page2_;
+  }
+
+ protected:
+  CFInvocation page1_;
+  CFInvocation page2_;
+};
+
+// This instantiates each parameterized test with some of the different CF
+// invocation methods.
+// TODO(kkania): Do not allow these tests to be cache the pages. This is used
+// currently because otherwise the meta tags can cause double requests. Change
+// ExpectAndServeRequestAllowCache to ExpectAndServeRequest when allowed.
+INSTANTIATE_TEST_CASE_P(
+    IEToIE,
+    NavigationTransitionTest,
+    testing::Values(NavigationTransitionTestParameter(
+        CFInvocation::NONE, CFInvocation::NONE)));
+INSTANTIATE_TEST_CASE_P(
+    IEToMetaTag,
+    NavigationTransitionTest,
+    testing::Values(NavigationTransitionTestParameter(
+        CFInvocation::NONE, CFInvocation::META_TAG)));
+INSTANTIATE_TEST_CASE_P(
+    IEToHttpHeader,
+    NavigationTransitionTest,
+    testing::Values(NavigationTransitionTestParameter(
+        CFInvocation::NONE, CFInvocation::HTTP_HEADER)));
+INSTANTIATE_TEST_CASE_P(
+    CFToCF,
+    NavigationTransitionTest,
+    testing::Values(NavigationTransitionTestParameter(
+        CFInvocation::META_TAG, CFInvocation::META_TAG)));
+INSTANTIATE_TEST_CASE_P(
+    CFToIE,
+    NavigationTransitionTest,
+    testing::Values(NavigationTransitionTestParameter(
+        CFInvocation::META_TAG, CFInvocation::NONE)));
+
+// Test window.open calls.
+// Marking this test as FLAKY initially as it relies on getting focus and user
+// input which don't work correctly at times.
+// http://code.google.com/p/chromium/issues/detail?id=26549
+TEST_P(NavigationTransitionTest, FLAKY_JavascriptWindowOpen) {
+  std::wstring parent_url = GetTestUrl(L"window_open.html?simple.html");
+  std::wstring new_window_url = GetSimplePageUrl();
+  MockIEEventSink new_window_mock;
+
+  ie_mock_.ExpectNavigation(page1_.invokes_cf(), parent_url);
+  server_mock_.ExpectAndServeRequestAllowCache(page1_, parent_url);
+  EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(parent_url)))
+      .WillOnce(testing::DoAll(
+          DelaySendMouseClick(&ie_mock_, &loop_, 0, 10, 10,
+              simulate_input::LEFT),
+          DelaySendMouseClick(&ie_mock_, &loop_, 100, 10, 10,
+              simulate_input::LEFT)));
+
+  // If the parent window is in CF, the child will load in CF regardless of
+  // whether the child page invokes CF.
+  bool expect_cf = page1_.invokes_cf() || page2_.invokes_cf();
+  ie_mock_.ExpectNewWindow(&new_window_mock);
+  new_window_mock.ExpectJavascriptWindowOpenNavigation(page1_.invokes_cf(),
+                                                       expect_cf,
+                                                       new_window_url);
+  server_mock_.ExpectAndServeRequestAllowCache(page2_, new_window_url);
+  EXPECT_CALL(new_window_mock, OnLoad(expect_cf, StrEq(new_window_url)))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&new_window_mock),
+          ValidateWindowSize(&new_window_mock, 10, 10, 250, 250),
+          CloseBrowserMock(&new_window_mock)));
+
+  EXPECT_CALL(new_window_mock, OnQuit())
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIENavigateAndLoop(parent_url,
+                          kChromeFrameLongNavigationTimeoutInSeconds * 2);
+}
+
+// Test redirection with window.location in Javascript.
+TEST_P(NavigationTransitionTest, FLAKY_JavascriptRedirection) {
+  std::wstring redirect_url = GetTestUrl(L"javascript_redirect.html");
+
+  ie_mock_.ExpectNavigation(page1_.invokes_cf(), redirect_url);
+  server_mock_.ExpectAndServeRequestAllowCache(page1_, redirect_url);
+  EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(redirect_url)))
+      .WillOnce(VerifyAddressBarUrl(&ie_mock_));
+
+  ie_mock_.ExpectNavigation(page2_.invokes_cf(), GetSimplePageUrl());
+  server_mock_.ExpectAndServeRequestAllowCache(page2_, GetSimplePageUrl());
+  EXPECT_CALL(ie_mock_, OnLoad(page2_.invokes_cf(), StrEq(GetSimplePageUrl())))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          CloseBrowserMock(&ie_mock_)));
+
+  LaunchIEAndNavigate(redirect_url);
+}
+
+// Test following a link by TAB + ENTER.
+TEST_P(NavigationTransitionTest, FLAKY_FollowLink) {
+  if (page1_.invokes_cf() && page2_.invokes_cf() &&
+      GetInstalledIEVersion() > IE_6) {
+    // For some reason IE 7 and 8 send two BeforeNavigate events for the second
+    // page.
+    return;
+  }
+  ie_mock_.ExpectNavigation(page1_.invokes_cf(), GetLinkPageUrl());
+  server_mock_.ExpectAndServeRequestAllowCache(page1_, GetLinkPageUrl());
+  EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(GetLinkPageUrl())))
+      .WillOnce(testing::DoAll(
+          DelaySendMouseClick(&ie_mock_, &loop_, 0, 1, 1,
+                              simulate_input::LEFT),
+          DelaySendScanCode(&loop_, 500, VK_TAB, simulate_input::NONE),
+          DelaySendScanCode(&loop_, 1000, VK_RETURN, simulate_input::NONE)));
+
+  ie_mock_.ExpectNavigation(page2_.invokes_cf(), GetSimplePageUrl());
+  server_mock_.ExpectAndServeRequestAllowCache(page2_, GetSimplePageUrl());
+  EXPECT_CALL(ie_mock_, OnLoad(page2_.invokes_cf(), StrEq(GetSimplePageUrl())))
+      .WillOnce(testing::DoAll(
+          VerifyAddressBarUrl(&ie_mock_),
+          CloseBrowserMock(&ie_mock_)));
+
+  LaunchIEAndNavigate(GetLinkPageUrl());
+}
+
+// Basic navigation test fixture which uses the MockIEEventSink. These tests
+// are not parameterized.
+class NavigationTest : public MockIEEventSinkTest, public testing::Test {
+ public:
+  NavigationTest() {}
+};
+
+// gMock matcher which tests if a url is blank.
+MATCHER(BlankUrl, "is \"\" or NULL") {
+  return arg == NULL || wcslen(arg) == 0;
+}
+
+// Test navigation to a disallowed url.
+TEST_F(NavigationTest, DisallowedUrl) {
+  // 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.
+  const wchar_t disallowed_url[] = L"gcf:file:///C:/";
+
+  EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                          StrEq(disallowed_url)),
+                                          _, _, _, _, _));
+  EXPECT_CALL(ie_mock_, OnLoad(IN_IE, BlankUrl()))
+      .Times(testing::AtMost(1));
+  EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                          testing::StartsWith(L"res:")),
+                                          _, _, _, _, _));
+  EXPECT_CALL(ie_mock_, OnFileDownload(VARIANT_TRUE, _))
+      .Times(testing::AnyNumber())
+      .WillRepeatedly(testing::Return());
+  EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, testing::Field(&VARIANT::bstrVal,
+                                            StrEq(disallowed_url))));
+  // Although we expect a load event for this, we should never receive a
+  // corresponding GET request.
+  EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(disallowed_url)))
+      .WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(disallowed_url);
+}
+
+// NOTE: This test is currently disabled as we haven't finished implementing
+// support for this yet.  The test (as written) works fine for IE.  CF might
+// have a different set of requirements once we fully support this and hence
+// the test might need some refining before being enabled.
+TEST_F(NavigationTest, DISABLED_DownloadInNewWindow) {
+  MockIEEventSink new_window_mock;
+  std::wstring kDownloadFromNewWin =
+      GetTestUrl(L"full_tab_download_from_new_window.html");
+
+  ie_mock_.ExpectNavigation(IN_CF, kDownloadFromNewWin);
+
+  EXPECT_CALL(ie_mock_, OnNewWindow3(_, _, _, _, _));
+
+  EXPECT_CALL(ie_mock_, OnNewBrowserWindow(_, _))
+      .WillOnce(testing::WithArgs<0>(testing::Invoke(testing::CreateFunctor(
+          &new_window_mock, &MockIEEventSink::Attach))));
+  EXPECT_CALL(new_window_mock, OnBeforeNavigate2(_, _, _, _, _, _, _));
+
+  EXPECT_CALL(new_window_mock, OnFileDownload(VARIANT_FALSE, _))
+          .Times(2)
+          .WillRepeatedly(CloseBrowserMock(&new_window_mock));
+
+  EXPECT_CALL(new_window_mock, OnNavigateComplete2(_, _));
+
+  EXPECT_CALL(new_window_mock, OnQuit()).WillOnce(CloseBrowserMock(&ie_mock_));
+
+  LaunchIEAndNavigate(kDownloadFromNewWin);
+}
+
+TEST_F(NavigationTest, KILL) {
+  ie_mock_.ExpectAnyNavigations();
+  LaunchIENavigateAndLoop(GetSimplePageUrl(), 4);
+}
+
+}  // namespace chrome_frame_test