| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <string> | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/test/test_file_util.h" | |
| 9 #include "base/win/scoped_comptr.h" | |
| 10 #include "base/win/windows_version.h" | |
| 11 #include "chrome_frame/test/chrome_frame_test_utils.h" | |
| 12 #include "chrome_frame/test/chrome_frame_ui_test_utils.h" | |
| 13 #include "chrome_frame/test/mock_ie_event_sink_actions.h" | |
| 14 #include "chrome_frame/test/mock_ie_event_sink_test.h" | |
| 15 #include "net/http/http_util.h" | |
| 16 | |
| 17 // Needed for CreateFunctor. | |
| 18 #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING | |
| 19 #include "testing/gmock_mutant.h" | |
| 20 | |
| 21 using testing::InSequence; | |
| 22 using testing::StrEq; | |
| 23 using testing::_; | |
| 24 | |
| 25 namespace chrome_frame_test { | |
| 26 | |
| 27 // Test fixture for navigation-related tests. Each test is run thrice: IE, CF | |
| 28 // with meta tag invocation, and CF with http header invocation. This is | |
| 29 // accomplished by using gTest's parameterized test. | |
| 30 class FullTabNavigationTest | |
| 31 : public MockIEEventSinkTest, public testing::TestWithParam<CFInvocation> { | |
| 32 public: | |
| 33 FullTabNavigationTest() {} | |
| 34 }; | |
| 35 | |
| 36 // Instantiate each test case. Instead of doing in one statement, it is split | |
| 37 // into three so gTest prints nicer names. | |
| 38 INSTANTIATE_TEST_CASE_P(IE, FullTabNavigationTest, testing::Values( | |
| 39 CFInvocation(CFInvocation::NONE))); | |
| 40 INSTANTIATE_TEST_CASE_P(MetaTag, FullTabNavigationTest, testing::Values( | |
| 41 CFInvocation(CFInvocation::META_TAG))); | |
| 42 INSTANTIATE_TEST_CASE_P(HttpHeader, FullTabNavigationTest, testing::Values( | |
| 43 CFInvocation(CFInvocation::HTTP_HEADER))); | |
| 44 | |
| 45 // This tests navigation to a typed URL. | |
| 46 TEST_P(FullTabNavigationTest, TypeUrl) { | |
| 47 MockAccEventObserver acc_observer; | |
| 48 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 49 AccObjectMatcher address_matcher(L"Address*", L"editable text"); | |
| 50 AccObjectMatcher go_matcher(L"Go*", L"push button"); | |
| 51 | |
| 52 ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl()); | |
| 53 server_mock_.ExpectAndServeRequest(CFInvocation::None(), GetSimplePageUrl()); | |
| 54 // Enter the new url into the address bar. | |
| 55 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl()))) | |
| 56 .WillOnce(testing::DoAll( | |
| 57 AccSetValueInBrowser(&ie_mock_, address_matcher, GetAnchorPageUrl(0)), | |
| 58 AccWatchForOneValueChange(&acc_observer, address_matcher))); | |
| 59 // Click the go button once the address has changed. | |
| 60 EXPECT_CALL(acc_observer, OnAccValueChange(_, _, GetAnchorPageUrl(0))) | |
| 61 .WillOnce(AccLeftClickInBrowser(&ie_mock_, go_matcher)); | |
| 62 | |
| 63 bool in_cf = GetParam().invokes_cf(); | |
| 64 ie_mock_.ExpectNavigation(in_cf, GetAnchorPageUrl(0)); | |
| 65 server_mock_.ExpectAndServeRequest(GetParam(), GetAnchorPageUrl(0)); | |
| 66 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(0)))) | |
| 67 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 68 | |
| 69 LaunchIEAndNavigate(GetSimplePageUrl()); | |
| 70 } | |
| 71 | |
| 72 // This tests navigation to a typed URL containing an fragment. | |
| 73 TEST_P(FullTabNavigationTest, TypeAnchorUrl) { | |
| 74 MockAccEventObserver acc_observer; | |
| 75 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 76 AccObjectMatcher address_matcher(L"Address*", L"editable text"); | |
| 77 AccObjectMatcher go_matcher(L"Go*", L"push button"); | |
| 78 | |
| 79 ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl()); | |
| 80 server_mock_.ExpectAndServeRequest(CFInvocation::None(), GetSimplePageUrl()); | |
| 81 | |
| 82 // Enter the new url into the address bar. | |
| 83 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl()))) | |
| 84 .WillOnce(testing::DoAll( | |
| 85 AccSetValueInBrowser(&ie_mock_, address_matcher, GetAnchorPageUrl(1)), | |
| 86 AccWatchForOneValueChange(&acc_observer, address_matcher))); | |
| 87 // Click the go button once the address has changed. | |
| 88 EXPECT_CALL(acc_observer, OnAccValueChange(_, _, GetAnchorPageUrl(1))) | |
| 89 .WillOnce(AccLeftClickInBrowser(&ie_mock_, go_matcher)); | |
| 90 | |
| 91 bool in_cf = GetParam().invokes_cf(); | |
| 92 ie_mock_.ExpectNavigation(in_cf, GetAnchorPageUrl(1)); | |
| 93 server_mock_.ExpectAndServeRequest(GetParam(), GetAnchorPageUrl(1)); | |
| 94 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(1)))) | |
| 95 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 96 | |
| 97 LaunchIEAndNavigate(GetSimplePageUrl()); | |
| 98 } | |
| 99 | |
| 100 // Tests refreshing causes a page load. | |
| 101 TEST_P(FullTabNavigationTest, Refresh) { | |
| 102 if (GetInstalledIEVersion() == IE_7) { | |
| 103 LOG(ERROR) << "Test disabled for this configuration."; | |
| 104 return; | |
| 105 } | |
| 106 bool in_cf = GetParam().invokes_cf(); | |
| 107 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 108 InSequence expect_in_sequence_for_scope; | |
| 109 | |
| 110 ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl()); | |
| 111 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl()))) | |
| 112 .WillOnce(DelayRefresh(&ie_mock_, &loop_, base::TimeDelta())); | |
| 113 | |
| 114 if (in_cf) { | |
| 115 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetSimplePageUrl()))) | |
| 116 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 117 } else { | |
| 118 // For some reason IE still requests the resource again, but does not | |
| 119 // trigger another load. | |
| 120 EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _)) | |
| 121 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 122 } | |
| 123 | |
| 124 LaunchIEAndNavigate(GetSimplePageUrl()); | |
| 125 } | |
| 126 | |
| 127 // Test that multiple back and forward requests work. | |
| 128 // TODO(tsepez): http://crbug.com/83133 | |
| 129 TEST_P(FullTabNavigationTest, DISABLED_MultipleBackForward) { | |
| 130 std::wstring page1 = GetSimplePageUrl(); | |
| 131 std::wstring page2 = GetLinkPageUrl(); | |
| 132 std::wstring page3 = GetAnchorPageUrl(0); | |
| 133 bool in_cf = GetParam().invokes_cf(); | |
| 134 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 135 InSequence expect_in_sequence_for_scope; | |
| 136 | |
| 137 // Navigate to url 2 after the previous navigation is complete. | |
| 138 ie_mock_.ExpectNavigation(in_cf, page1); | |
| 139 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1))) | |
| 140 .WillOnce(testing::DoAll( | |
| 141 VerifyAddressBarUrl(&ie_mock_), | |
| 142 Navigate(&ie_mock_, page2))); | |
| 143 | |
| 144 // Navigate to url 3 after the previous navigation is complete. | |
| 145 ie_mock_.ExpectNavigation(in_cf, page2); | |
| 146 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2))) | |
| 147 .WillOnce(testing::DoAll( | |
| 148 VerifyAddressBarUrl(&ie_mock_), | |
| 149 Navigate(&ie_mock_, page3))); | |
| 150 | |
| 151 // We have reached url 3 and have two back entries for url 1 & 2. | |
| 152 // Go back to url 2 now. | |
| 153 ie_mock_.ExpectNavigation(in_cf, page3); | |
| 154 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page3))) | |
| 155 .WillOnce(testing::DoAll( | |
| 156 VerifyAddressBarUrl(&ie_mock_), | |
| 157 DelayGoBack(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 158 | |
| 159 // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3. | |
| 160 // Go back to url 1 now. | |
| 161 ie_mock_.ExpectNavigation(in_cf, page2); | |
| 162 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2))) | |
| 163 .WillOnce(testing::DoAll( | |
| 164 VerifyAddressBarUrl(&ie_mock_), | |
| 165 DelayGoBack(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 166 | |
| 167 // We have reached url 1 and have 0 back & 2 forward entries for url 2 & 3. | |
| 168 // Go forward to url 2 now. | |
| 169 ie_mock_.ExpectNavigation(in_cf, page1); | |
| 170 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1))) | |
| 171 .WillOnce(testing::DoAll( | |
| 172 VerifyAddressBarUrl(&ie_mock_), | |
| 173 DelayGoForward(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 174 | |
| 175 // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3. | |
| 176 // Go forward to url 3 now. | |
| 177 ie_mock_.ExpectNavigation(in_cf, page2); | |
| 178 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2))) | |
| 179 .WillOnce(testing::DoAll( | |
| 180 VerifyAddressBarUrl(&ie_mock_), | |
| 181 DelayGoForward(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 182 | |
| 183 // We have reached url 2 and have 1 back & 1 forward entries for url 1 & 3. | |
| 184 ie_mock_.ExpectNavigation(in_cf, page3); | |
| 185 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page3))) | |
| 186 .WillOnce(testing::DoAll( | |
| 187 VerifyAddressBarUrl(&ie_mock_), | |
| 188 CloseBrowserMock(&ie_mock_))); | |
| 189 | |
| 190 LaunchIENavigateAndLoop(page1, kChromeFrameLongNavigationTimeout * 2); | |
| 191 } | |
| 192 | |
| 193 // Test multiple back and forward operations among urls with anchors. | |
| 194 TEST_P(FullTabNavigationTest, BackForwardAnchor) { | |
| 195 std::wstring title(GetAnchorPageTitle()); | |
| 196 bool in_cf = GetParam().invokes_cf(); | |
| 197 ie_mock_.ExpectAnyNavigations(); | |
| 198 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 199 MockAccEventObserver acc_observer; | |
| 200 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 201 | |
| 202 // Navigate to anchor 1. | |
| 203 // Back/Forward state at this point: | |
| 204 // Back: 0 | |
| 205 // Forward: 0 | |
| 206 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(0)))) | |
| 207 .Times(testing::AtMost(1)); | |
| 208 EXPECT_CALL(acc_observer, OnAccDocLoad(TabContentsTitleEq(GetAnchorPageUrl(0), | |
| 209 title))) | |
| 210 .WillOnce(AccDoDefaultAction(AccObjectMatcher(L"*1", L"link"))) | |
| 211 .RetiresOnSaturation(); | |
| 212 | |
| 213 InSequence expect_in_sequence_for_scope; | |
| 214 // Navigate to anchor 2 after the previous navigation is complete | |
| 215 // Back/Forward state at this point: | |
| 216 // Back: 1 (kAnchorUrl) | |
| 217 // Forward: 0 | |
| 218 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(1)))) | |
| 219 .WillOnce(testing::DoAll( | |
| 220 VerifyAddressBarUrl(&ie_mock_), | |
| 221 AccDoDefaultActionInRenderer(&ie_mock_, | |
| 222 AccObjectMatcher(L"*2", L"link")))); | |
| 223 | |
| 224 // Navigate to anchor 3 after the previous navigation is complete | |
| 225 // Back/Forward state at this point: | |
| 226 // Back: 2 (kAnchorUrl, kAnchor1Url) | |
| 227 // Forward: 0 | |
| 228 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(2)))) | |
| 229 .WillOnce(testing::DoAll( | |
| 230 VerifyAddressBarUrl(&ie_mock_), | |
| 231 AccDoDefaultActionInRenderer(&ie_mock_, | |
| 232 AccObjectMatcher(L"*3", L"link")))); | |
| 233 | |
| 234 // We will reach anchor 3 once the navigation is complete, | |
| 235 // then go back to anchor 2 | |
| 236 // Back/Forward state at this point: | |
| 237 // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url) | |
| 238 // Forward: 0 | |
| 239 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(3)))) | |
| 240 .WillOnce(testing::DoAll( | |
| 241 VerifyAddressBarUrl(&ie_mock_), | |
| 242 DelayGoBack(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 243 | |
| 244 // We will reach anchor 2 once the navigation is complete, | |
| 245 // then go back to anchor 1 | |
| 246 // Back/Forward state at this point: | |
| 247 // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url) | |
| 248 // Forward: 1 (kAnchor3Url) | |
| 249 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(2)))) | |
| 250 .WillOnce(testing::DoAll( | |
| 251 VerifyAddressBarUrl(&ie_mock_), | |
| 252 DelayGoBack(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 253 | |
| 254 // We will reach anchor 1 once the navigation is complete, | |
| 255 // now go forward to anchor 2 | |
| 256 // Back/Forward state at this point: | |
| 257 // Back: 2 (kAnchorUrl, kAnchor1Url) | |
| 258 // Forward: 2 (kAnchor2Url, kAnchor3Url) | |
| 259 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(1)))) | |
| 260 .WillOnce(testing::DoAll( | |
| 261 VerifyAddressBarUrl(&ie_mock_), | |
| 262 DelayGoForward(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 263 | |
| 264 // We have reached anchor 2, go forward to anchor 3 again | |
| 265 // Back/Forward state at this point: | |
| 266 // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url) | |
| 267 // Forward: 1 (kAnchor3Url) | |
| 268 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(2)))) | |
| 269 .WillOnce(testing::DoAll( | |
| 270 VerifyAddressBarUrl(&ie_mock_), | |
| 271 DelayGoForward(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 272 | |
| 273 // We have gone a few steps back and forward, this should be enough for now. | |
| 274 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(GetAnchorPageUrl(3)))) | |
| 275 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 276 | |
| 277 LaunchIEAndNavigate(GetAnchorPageUrl(0)); | |
| 278 } | |
| 279 | |
| 280 // Test that a user cannot navigate to a restricted site and that the security | |
| 281 // dialog appears. | |
| 282 TEST_P(FullTabNavigationTest, RestrictedSite) { | |
| 283 // Add the server to restricted sites zone. | |
| 284 base::win::ScopedComPtr<IInternetSecurityManager> security_manager; | |
| 285 HRESULT hr = security_manager.CreateInstance(CLSID_InternetSecurityManager); | |
| 286 ASSERT_HRESULT_SUCCEEDED(hr); | |
| 287 hr = security_manager->SetZoneMapping(URLZONE_UNTRUSTED, | |
| 288 GetTestUrl(L"").c_str(), SZM_CREATE); | |
| 289 | |
| 290 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 291 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 292 | |
| 293 MockWindowObserver win_observer_mock; | |
| 294 | |
| 295 // If the page is loaded in mshtml, then IE allows the page to be loaded | |
| 296 // and just shows 'Restricted sites' in the status bar. | |
| 297 if (!GetParam().invokes_cf()) { | |
| 298 ie_mock_.ExpectNavigation(IN_IE, GetSimplePageUrl()); | |
| 299 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl()))) | |
| 300 .Times(1) | |
| 301 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 302 } else { | |
| 303 // If the page is being loaded in chrome frame then we will see | |
| 304 // a security dialog. | |
| 305 const char* kAlertDlgCaption = "Security Alert"; | |
| 306 win_observer_mock.WatchWindow(kAlertDlgCaption, ""); | |
| 307 | |
| 308 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 309 testing::HasSubstr(GetSimplePageUrl())), _, _, _, _, _)) | |
| 310 .Times(testing::AtMost(2)); | |
| 311 | |
| 312 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 313 testing::Field(&VARIANT::bstrVal, StrEq(GetSimplePageUrl())))) | |
| 314 .Times(testing::AtMost(1)); | |
| 315 | |
| 316 EXPECT_CALL(win_observer_mock, OnWindowOpen(_)) | |
| 317 .Times(1) | |
| 318 .WillOnce(DoCloseWindow()); | |
| 319 EXPECT_CALL(win_observer_mock, OnWindowClose(_)) | |
| 320 .Times(1) | |
| 321 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 322 } | |
| 323 | |
| 324 LaunchIEAndNavigate(GetSimplePageUrl()); | |
| 325 | |
| 326 ASSERT_HRESULT_SUCCEEDED(security_manager->SetZoneMapping(URLZONE_UNTRUSTED, | |
| 327 GetTestUrl(L"").c_str(), SZM_DELETE)); | |
| 328 } | |
| 329 | |
| 330 // This test checks if window.open calls with target blank issued for a | |
| 331 // different domain make it back to IE instead of completing the navigation | |
| 332 // within Chrome. We validate this by initiating a navigation to a non existent | |
| 333 // url which ensures we would get an error during navigation. | |
| 334 // Marking this disabled as it leaves behind Chrome processes, at least on | |
| 335 // IE 6 XP (http://crbug.com/48732). | |
| 336 TEST_P(FullTabNavigationTest, DISABLED_JavascriptWindowOpenDifferentDomain) { | |
| 337 if (!GetParam().invokes_cf() || GetInstalledIEVersion() == IE_7) { | |
| 338 LOG(ERROR) << "Test disabled for this configuration."; | |
| 339 return; | |
| 340 } | |
| 341 std::wstring parent_url = GetWindowOpenUrl(L"http://www.nonexistent.com"); | |
| 342 MockAccEventObserver acc_observer; | |
| 343 MockIEEventSink new_window_mock; | |
| 344 ie_mock_.ExpectAnyNavigations(); | |
| 345 new_window_mock.ExpectAnyNavigations(); | |
| 346 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 347 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 348 | |
| 349 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(), StrEq(parent_url))); | |
| 350 EXPECT_CALL(acc_observer, | |
| 351 OnAccDocLoad(TabContentsTitleEq(parent_url, | |
| 352 GetWindowOpenTitle()))) | |
| 353 .WillOnce(AccLeftClick(AccObjectMatcher())); | |
| 354 | |
| 355 ie_mock_.ExpectNewWindow(&new_window_mock); | |
| 356 EXPECT_CALL(new_window_mock, OnNavigateError(_, _, _, _, _)) | |
| 357 .Times(1) | |
| 358 .WillOnce(CloseBrowserMock(&new_window_mock)); | |
| 359 | |
| 360 EXPECT_CALL(new_window_mock, OnLoad(_, _)) | |
| 361 .Times(testing::AtMost(1)); | |
| 362 | |
| 363 EXPECT_CALL(new_window_mock, OnQuit()) | |
| 364 .Times(1) | |
| 365 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 366 | |
| 367 // OnNavigateError can take a long time to fire. | |
| 368 LaunchIENavigateAndLoop(parent_url, kChromeFrameLongNavigationTimeout * 4); | |
| 369 ASSERT_TRUE(new_window_mock.event_sink()->web_browser2() != NULL); | |
| 370 } | |
| 371 | |
| 372 // Tests that the parent window can successfully close its popup through | |
| 373 // the javascript close method. | |
| 374 TEST_P(FullTabNavigationTest, JavascriptWindowOpenCanClose) { | |
| 375 // Please see http://code.google.com/p/chromium/issues/detail?id=60987 | |
| 376 // for more information on why this test is disabled for Vista with IE7. | |
| 377 if (base::win::GetVersion() == base::win::VERSION_VISTA && | |
| 378 GetInstalledIEVersion() == IE_7) { | |
| 379 LOG(INFO) << "Not running test on Vista with IE7"; | |
| 380 return; | |
| 381 } | |
| 382 | |
| 383 std::wstring parent_url = GetWindowOpenUrl(L"simple.html"); | |
| 384 MockAccEventObserver acc_observer; | |
| 385 MockIEEventSink new_window_mock; | |
| 386 ie_mock_.ExpectAnyNavigations(); | |
| 387 new_window_mock.ExpectAnyNavigations(); | |
| 388 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 389 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 390 | |
| 391 // Tell the page to open the popup. Some versions of IE will prevent a popup | |
| 392 // unless a click is involved. | |
| 393 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(), StrEq(parent_url))); | |
| 394 EXPECT_CALL(acc_observer, | |
| 395 OnAccDocLoad(TabContentsTitleEq(parent_url, | |
| 396 GetWindowOpenTitle()))) | |
| 397 .WillOnce(AccLeftClick(AccObjectMatcher())); | |
| 398 | |
| 399 ie_mock_.ExpectNewWindow(&new_window_mock); | |
| 400 EXPECT_CALL(new_window_mock, OnLoad(_, StrEq(GetSimplePageUrl()))) | |
| 401 .Times(testing::AtMost(2)) | |
| 402 .WillOnce(PostKeyMessageToRenderer(&ie_mock_, 'c')) // close the popup | |
| 403 .WillOnce(testing::Return()); | |
| 404 | |
| 405 EXPECT_CALL(new_window_mock, OnQuit()) | |
| 406 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 407 | |
| 408 LaunchIENavigateAndLoop(parent_url, kChromeFrameLongNavigationTimeout * 2); | |
| 409 } | |
| 410 | |
| 411 // Parameter for tests using the NavigationTransitionTest fixture. Includes two | |
| 412 // pages, each with their own possible CF invocation. | |
| 413 struct NavigationTransitionTestParameter { | |
| 414 NavigationTransitionTestParameter(CFInvocation::Type type1, | |
| 415 CFInvocation::Type type2) { | |
| 416 page1_ = CFInvocation(type1); | |
| 417 page2_ = CFInvocation(type2); | |
| 418 } | |
| 419 CFInvocation page1_; | |
| 420 CFInvocation page2_; | |
| 421 }; | |
| 422 | |
| 423 // Parameterized test fixture for tests which test navigation transitions | |
| 424 // between two pages. | |
| 425 class NavigationTransitionTest | |
| 426 : public MockIEEventSinkTest, | |
| 427 public testing::TestWithParam<NavigationTransitionTestParameter> { | |
| 428 public: | |
| 429 NavigationTransitionTest() {} | |
| 430 | |
| 431 virtual void SetUp() { | |
| 432 page1_ = GetParam().page1_; | |
| 433 page2_ = GetParam().page2_; | |
| 434 } | |
| 435 | |
| 436 protected: | |
| 437 CFInvocation page1_; | |
| 438 CFInvocation page2_; | |
| 439 }; | |
| 440 | |
| 441 // This instantiates each parameterized test with some of the different CF | |
| 442 // invocation methods. | |
| 443 INSTANTIATE_TEST_CASE_P( | |
| 444 IEToIE, | |
| 445 NavigationTransitionTest, | |
| 446 testing::Values(NavigationTransitionTestParameter( | |
| 447 CFInvocation::NONE, CFInvocation::NONE))); | |
| 448 INSTANTIATE_TEST_CASE_P( | |
| 449 IEToMetaTag, | |
| 450 NavigationTransitionTest, | |
| 451 testing::Values(NavigationTransitionTestParameter( | |
| 452 CFInvocation::NONE, CFInvocation::META_TAG))); | |
| 453 INSTANTIATE_TEST_CASE_P( | |
| 454 IEToHttpHeader, | |
| 455 NavigationTransitionTest, | |
| 456 testing::Values(NavigationTransitionTestParameter( | |
| 457 CFInvocation::NONE, CFInvocation::HTTP_HEADER))); | |
| 458 INSTANTIATE_TEST_CASE_P( | |
| 459 CFToCF, | |
| 460 NavigationTransitionTest, | |
| 461 testing::Values(NavigationTransitionTestParameter( | |
| 462 CFInvocation::META_TAG, CFInvocation::META_TAG))); | |
| 463 INSTANTIATE_TEST_CASE_P( | |
| 464 CFToIE, | |
| 465 NavigationTransitionTest, | |
| 466 testing::Values(NavigationTransitionTestParameter( | |
| 467 CFInvocation::META_TAG, CFInvocation::NONE))); | |
| 468 | |
| 469 // Test window.open calls. | |
| 470 TEST_P(NavigationTransitionTest, JavascriptWindowOpen) { | |
| 471 // Please see http://code.google.com/p/chromium/issues/detail?id=60987 | |
| 472 // for more information on why this test is disabled for Vista with IE7. | |
| 473 if (base::win::GetVersion() == base::win::VERSION_VISTA && | |
| 474 GetInstalledIEVersion() == IE_7) { | |
| 475 LOG(INFO) << "Not running test on Vista with IE7"; | |
| 476 return; | |
| 477 } | |
| 478 | |
| 479 std::wstring parent_url = GetWindowOpenUrl(L"simple.html"); | |
| 480 std::wstring new_window_url = GetSimplePageUrl(); | |
| 481 MockAccEventObserver acc_observer; | |
| 482 testing::StrictMock<MockIEEventSink> new_window_mock; | |
| 483 | |
| 484 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 485 ie_mock_.ExpectNavigation(page1_.invokes_cf(), parent_url); | |
| 486 server_mock_.ExpectAndServeRequest(page1_, parent_url); | |
| 487 EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(parent_url))); | |
| 488 // Tell the page to open the popup. Some versions of IE will prevent a popup | |
| 489 // unless a click is involved. | |
| 490 EXPECT_CALL(acc_observer, | |
| 491 OnAccDocLoad(TabContentsTitleEq(parent_url, | |
| 492 GetWindowOpenTitle()))) | |
| 493 .WillOnce(AccLeftClick(AccObjectMatcher())); | |
| 494 | |
| 495 // If the parent window is in CF, the child should always load in CF since | |
| 496 // the domain is the same. | |
| 497 bool expect_cf = page1_.invokes_cf() || page2_.invokes_cf(); | |
| 498 ie_mock_.ExpectNewWindow(&new_window_mock); | |
| 499 new_window_mock.ExpectJavascriptWindowOpenNavigation(page1_.invokes_cf(), | |
| 500 expect_cf, | |
| 501 new_window_url); | |
| 502 server_mock_.ExpectAndServeRequest(page2_, new_window_url); | |
| 503 EXPECT_CALL(new_window_mock, OnLoad(expect_cf, StrEq(new_window_url))) | |
| 504 .WillOnce(testing::DoAll( | |
| 505 ValidateWindowSize(&new_window_mock, 10, 10, 250, 250), | |
| 506 CloseBrowserMock(&new_window_mock))); | |
| 507 | |
| 508 EXPECT_CALL(new_window_mock, OnQuit()) | |
| 509 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 510 | |
| 511 LaunchIENavigateAndLoop(parent_url, kChromeFrameLongNavigationTimeout * 2); | |
| 512 } | |
| 513 | |
| 514 // Test redirection with window.location in Javascript. | |
| 515 // Disabled because crashes IE occasionally: http://crbug.com/48849. | |
| 516 TEST_P(NavigationTransitionTest, DISABLED_JavascriptRedirection) { | |
| 517 std::wstring redirect_url = GetTestUrl(L"javascript_redirect.html"); | |
| 518 | |
| 519 ie_mock_.ExpectNavigation(page1_.invokes_cf(), redirect_url); | |
| 520 server_mock_.ExpectAndServeRequest(page1_, redirect_url); | |
| 521 EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(redirect_url))) | |
| 522 .WillOnce(VerifyAddressBarUrl(&ie_mock_)); | |
| 523 | |
| 524 ie_mock_.ExpectNavigation(page2_.invokes_cf(), GetSimplePageUrl()); | |
| 525 server_mock_.ExpectAndServeRequest(page2_, GetSimplePageUrl()); | |
| 526 EXPECT_CALL(ie_mock_, OnLoad(page2_.invokes_cf(), StrEq(GetSimplePageUrl()))) | |
| 527 .WillOnce(testing::DoAll( | |
| 528 VerifyAddressBarUrl(&ie_mock_), | |
| 529 CloseBrowserMock(&ie_mock_))); | |
| 530 | |
| 531 LaunchIEAndNavigate(redirect_url); | |
| 532 } | |
| 533 | |
| 534 // Test following a link. | |
| 535 TEST_P(NavigationTransitionTest, FollowLink) { | |
| 536 if (page1_.invokes_cf() && page2_.invokes_cf()) { | |
| 537 // For some reason IE 7 and 8 send two BeforeNavigate events for the second | |
| 538 // page for this case. All versions do not send the OnLoad event for the | |
| 539 // second page if both pages are renderered in CF. | |
| 540 LOG(ERROR) << "Test disabled for this configuration."; | |
| 541 return; | |
| 542 } | |
| 543 MockAccEventObserver acc_observer; | |
| 544 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 545 | |
| 546 ie_mock_.ExpectNavigation(page1_.invokes_cf(), GetLinkPageUrl()); | |
| 547 // Two requests are made when going from CF to IE, at least on Win7 IE8. | |
| 548 EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetLinkPageUrl()), _)) | |
| 549 .Times(testing::Between(1, 2)) | |
| 550 .WillRepeatedly(SendResponse(&server_mock_, page1_)); | |
| 551 EXPECT_CALL(ie_mock_, OnLoad(page1_.invokes_cf(), StrEq(GetLinkPageUrl()))); | |
| 552 EXPECT_CALL(acc_observer, | |
| 553 OnAccDocLoad(TabContentsTitleEq(GetLinkPageUrl(), | |
| 554 GetLinkPageTitle()))) | |
| 555 .WillOnce(AccDoDefaultAction(AccObjectMatcher(L"", L"link"))) | |
| 556 .RetiresOnSaturation(); | |
| 557 | |
| 558 ie_mock_.ExpectNavigation(page2_.invokes_cf(), GetSimplePageUrl()); | |
| 559 server_mock_.ExpectAndServeRequest(page2_, GetSimplePageUrl()); | |
| 560 EXPECT_CALL(ie_mock_, OnLoad(page2_.invokes_cf(), StrEq(GetSimplePageUrl()))) | |
| 561 .WillOnce(testing::DoAll( | |
| 562 VerifyAddressBarUrl(&ie_mock_), | |
| 563 CloseBrowserMock(&ie_mock_))); | |
| 564 | |
| 565 LaunchIEAndNavigate(GetLinkPageUrl()); | |
| 566 } | |
| 567 | |
| 568 // gMock matcher which tests if a url is blank. | |
| 569 MATCHER(BlankUrl, "is \"\" or NULL") { | |
| 570 return arg == NULL || wcslen(arg) == 0; | |
| 571 } | |
| 572 | |
| 573 // Basic navigation test fixture which uses the MockIEEventSink. These tests | |
| 574 // are not parameterized. | |
| 575 class NavigationTest : public MockIEEventSinkTest, public testing::Test { | |
| 576 public: | |
| 577 NavigationTest() {} | |
| 578 | |
| 579 void TestDisAllowedUrl(const wchar_t* url) { | |
| 580 // If a navigation fails then IE issues a navigation to an interstitial | |
| 581 // page. Catch this to track navigation errors as the NavigateError | |
| 582 // notification does not seem to fire reliably. | |
| 583 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 584 StrEq(url)), | |
| 585 _, _, _, _, _)); | |
| 586 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, BlankUrl())) | |
| 587 .Times(testing::AtMost(1)); | |
| 588 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 589 testing::StartsWith(L"res:")), | |
| 590 _, _, _, _, _)); | |
| 591 EXPECT_CALL(ie_mock_, OnFileDownload(VARIANT_TRUE, _)) | |
| 592 .Times(testing::AnyNumber()) | |
| 593 .WillRepeatedly(testing::Return()); | |
| 594 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 595 testing::Field(&VARIANT::bstrVal, | |
| 596 StrEq(url)))); | |
| 597 // Although we expect a load event for this, we should never receive a | |
| 598 // corresponding GET request. | |
| 599 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(url))) | |
| 600 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 601 | |
| 602 LaunchIEAndNavigate(url); | |
| 603 } | |
| 604 | |
| 605 }; | |
| 606 | |
| 607 // Test navigation to a disallowed gcf: url with file scheme. | |
| 608 // Times out sporadically; http://crbug.com/119718. | |
| 609 TEST_F(NavigationTest, DISABLED_GcfProtocol1) { | |
| 610 // Make sure that we are not accidently enabling gcf protocol. | |
| 611 SetConfigBool(kAllowUnsafeURLs, false); | |
| 612 TestDisAllowedUrl(L"gcf:file:///C:/"); | |
| 613 } | |
| 614 | |
| 615 // Test navigation to a disallowed gcf: url with http scheme. | |
| 616 TEST_F(NavigationTest, GcfProtocol2) { | |
| 617 // Make sure that we are not accidently enabling gcf protocol. | |
| 618 SetConfigBool(kAllowUnsafeURLs, false); | |
| 619 TestDisAllowedUrl(L"gcf:http://www.google.com"); | |
| 620 } | |
| 621 | |
| 622 // Test navigation to a disallowed gcf: url with https scheme. | |
| 623 TEST_F(NavigationTest, GcfProtocol3) { | |
| 624 // Make sure that we are not accidently enabling gcf protocol. | |
| 625 SetConfigBool(kAllowUnsafeURLs, false); | |
| 626 TestDisAllowedUrl(L"gcf:https://www.google.com"); | |
| 627 } | |
| 628 | |
| 629 // NOTE: This test is currently disabled as we haven't finished implementing | |
| 630 // support for this yet. The test (as written) works fine for IE. CF might | |
| 631 // have a different set of requirements once we fully support this and hence | |
| 632 // the test might need some refining before being enabled. | |
| 633 TEST_F(NavigationTest, DISABLED_DownloadInNewWindow) { | |
| 634 MockIEEventSink new_window_mock; | |
| 635 std::wstring kDownloadFromNewWin = | |
| 636 GetTestUrl(L"full_tab_download_from_new_window.html"); | |
| 637 | |
| 638 ie_mock_.ExpectNavigation(IN_CF, kDownloadFromNewWin); | |
| 639 | |
| 640 EXPECT_CALL(ie_mock_, OnNewWindow3(_, _, _, _, _)); | |
| 641 | |
| 642 EXPECT_CALL(ie_mock_, OnNewBrowserWindow(_, _)) | |
| 643 .WillOnce(testing::WithArgs<0>(testing::Invoke(testing::CreateFunctor( | |
| 644 &new_window_mock, &MockIEEventSink::Attach)))); | |
| 645 EXPECT_CALL(new_window_mock, OnBeforeNavigate2(_, _, _, _, _, _, _)); | |
| 646 | |
| 647 EXPECT_CALL(new_window_mock, OnFileDownload(VARIANT_FALSE, _)) | |
| 648 .Times(2) | |
| 649 .WillRepeatedly(CloseBrowserMock(&new_window_mock)); | |
| 650 | |
| 651 EXPECT_CALL(new_window_mock, OnNavigateComplete2(_, _)); | |
| 652 | |
| 653 EXPECT_CALL(new_window_mock, OnQuit()).WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 654 | |
| 655 LaunchIEAndNavigate(kDownloadFromNewWin); | |
| 656 } | |
| 657 | |
| 658 // Flaky on ie6, http://crbug.com/255098. | |
| 659 TEST_P(FullTabNavigationTest, DISABLED_FormPostBackForward) { | |
| 660 bool in_cf = GetParam().invokes_cf(); | |
| 661 // Navigate to the form-get.html page: | |
| 662 // - First set focus to chrome renderer window | |
| 663 // - Send over a character to the window. | |
| 664 // - This should initiate a form post which eventually navigates to the | |
| 665 // action.html page. | |
| 666 // Navigate backwards from the action.html page and then navigate forward | |
| 667 // from the form-get.html page. | |
| 668 std::wstring kFormPostUrl = GetTestUrl(L"form-get.html"); | |
| 669 std::wstring kFormPostActionUrl = | |
| 670 GetTestUrl(L"action.html?field1=a&field2=b&submit=Submit"); | |
| 671 std::wstring kFormPostTitle(L"ChromeFrame form submit test(GET method)"); | |
| 672 | |
| 673 MockAccEventObserver acc_observer; | |
| 674 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 675 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 676 | |
| 677 EXPECT_CALL(acc_observer, OnAccDocLoad(TabContentsTitleEq(kFormPostUrl, | |
| 678 kFormPostTitle))) | |
| 679 .WillOnce(AccDoDefaultAction(AccObjectMatcher(L"Submit"))) | |
| 680 .RetiresOnSaturation(); | |
| 681 | |
| 682 InSequence expect_in_sequence_for_scope; | |
| 683 | |
| 684 ie_mock_.ExpectNavigation(in_cf, kFormPostUrl); | |
| 685 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kFormPostUrl))); | |
| 686 | |
| 687 ie_mock_.ExpectNavigationOptionalBefore(in_cf, kFormPostActionUrl); | |
| 688 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kFormPostActionUrl))) | |
| 689 .WillOnce(testing::DoAll( | |
| 690 VerifyAddressBarUrl(&ie_mock_), | |
| 691 DelayGoBack(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 692 | |
| 693 ie_mock_.ExpectNavigation(in_cf, kFormPostUrl); | |
| 694 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kFormPostUrl))) | |
| 695 .WillOnce(testing::DoAll( | |
| 696 VerifyAddressBarUrl(&ie_mock_), | |
| 697 DelayGoForward(&ie_mock_, &loop_, base::TimeDelta()))); | |
| 698 | |
| 699 ie_mock_.ExpectNavigationOptionalBefore(in_cf, kFormPostActionUrl); | |
| 700 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kFormPostActionUrl))) | |
| 701 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 702 | |
| 703 LaunchIEAndNavigate(kFormPostUrl); | |
| 704 } | |
| 705 | |
| 706 TEST_P(FullTabNavigationTest, CF_UnloadEventTest) { | |
| 707 bool in_cf = GetParam().invokes_cf(); | |
| 708 if (!in_cf) { | |
| 709 LOG(ERROR) << "Test not yet implemented."; | |
| 710 return; | |
| 711 } | |
| 712 | |
| 713 std::wstring kUnloadEventTestUrl = | |
| 714 GetTestUrl(L"fulltab_before_unload_event_test.html"); | |
| 715 | |
| 716 std::wstring kUnloadEventMainUrl = | |
| 717 GetTestUrl(L"fulltab_before_unload_event_main.html"); | |
| 718 | |
| 719 server_mock_.ExpectAndServeAnyRequests(GetParam()); | |
| 720 InSequence expect_in_sequence_for_scope; | |
| 721 | |
| 722 ie_mock_.ExpectNavigation(in_cf, kUnloadEventTestUrl); | |
| 723 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kUnloadEventTestUrl))); | |
| 724 | |
| 725 ie_mock_.ExpectNavigationOptionalBefore(in_cf, kUnloadEventMainUrl); | |
| 726 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(kUnloadEventMainUrl))); | |
| 727 | |
| 728 EXPECT_CALL(ie_mock_, OnMessage(_, _, _)) | |
| 729 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 730 | |
| 731 LaunchIEAndNavigate(kUnloadEventTestUrl); | |
| 732 } | |
| 733 | |
| 734 // Fixture for ChromeFrame download tests. | |
| 735 class FullTabDownloadTest | |
| 736 : public MockIEEventSinkTest, public testing::TestWithParam<CFInvocation> { | |
| 737 public: | |
| 738 FullTabDownloadTest() {} | |
| 739 }; | |
| 740 | |
| 741 void SaveOwnerWindow(HWND* owner_window, HWND window) { | |
| 742 *owner_window = GetWindow(window, GW_OWNER); | |
| 743 } | |
| 744 | |
| 745 void CloseWindow(HWND* window) { | |
| 746 if (window) | |
| 747 PostMessage(*window, WM_CLOSE, 0, 0); | |
| 748 } | |
| 749 | |
| 750 // See bug http://crbug.com/36694 | |
| 751 // This test does the following:- | |
| 752 // Navigates IE to a URL which in ChromeFrame. | |
| 753 // Performs a top level form post in the document | |
| 754 // In response to the POST we send over an attachment via the | |
| 755 // content-disposition header. | |
| 756 // IE brings up a file open dialog in this context. | |
| 757 // We bring up the Save dialog via accessibility and save the file | |
| 758 // and validate that all is well. | |
| 759 TEST_F(FullTabDownloadTest, CF_DownloadFileFromPost) { | |
| 760 // Please see http://code.google.com/p/chromium/issues/detail?id=60987 | |
| 761 // for more information on why this test is disabled for Vista with IE7. | |
| 762 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { | |
| 763 if (GetInstalledIEVersion() == IE_7) { | |
| 764 LOG(INFO) << "Not running test on Vista with IE7"; | |
| 765 return; | |
| 766 } else if (GetInstalledIEVersion() == IE_9) { | |
| 767 LOG(INFO) << "Not running test on Vista/Windows 7 with IE9"; | |
| 768 return; | |
| 769 } | |
| 770 } | |
| 771 | |
| 772 chrome_frame_test::MockWindowObserver download_watcher; | |
| 773 download_watcher.WatchWindow("File Download", ""); | |
| 774 | |
| 775 chrome_frame_test::MockWindowObserver save_dialog_watcher; | |
| 776 save_dialog_watcher.WatchWindow("Save As", ""); | |
| 777 | |
| 778 testing::StrictMock<MockIEEventSink> download_window_mock; | |
| 779 | |
| 780 EXPECT_CALL(server_mock_, Get(_, StrEq(L"/post_source.html"), _)).WillOnce( | |
| 781 SendFast( | |
| 782 "HTTP/1.1 200 OK\r\n" | |
| 783 "Content-Type: text/html\r\n", | |
| 784 "<html>" | |
| 785 "<head><meta http-equiv=\"x-ua-compatible\" content=\"chrome=1\" />" | |
| 786 " <script type=\"text/javascript\">" | |
| 787 " function onLoad() {" | |
| 788 " document.getElementById(\"myform\").submit();}</script></head>" | |
| 789 " <body onload=\"setTimeout(onLoad, 2000);\">" | |
| 790 " <form id=\"myform\" action=\"post_target.html\" method=\"POST\">" | |
| 791 "</form></body></html>")); | |
| 792 | |
| 793 EXPECT_CALL(server_mock_, Post(_, StrEq(L"/post_target.html"), _)) | |
| 794 .Times(2) | |
| 795 .WillRepeatedly( | |
| 796 SendFast( | |
| 797 "HTTP/1.1 200 OK\r\n" | |
| 798 "content-disposition: attachment;filename=\"hello.txt\"\r\n" | |
| 799 "Content-Type: application/text\r\n" | |
| 800 "Cache-Control: private\r\n", | |
| 801 "hello")); | |
| 802 | |
| 803 // If you want to debug this action then you may need to | |
| 804 // SendMessage(parent_window, WM_NCACTIVATE, TRUE, 0); | |
| 805 // SendMessage(parent_window, WM_COMMAND, MAKEWPARAM(0x114B, BN_CLICKED), | |
| 806 // control_window); | |
| 807 // For the uninitiated, please debug IEFrame!CDialogActivateGuard::* | |
| 808 EXPECT_CALL(download_watcher, OnWindowOpen(_)) | |
| 809 .Times(2) | |
| 810 .WillOnce(DelayAccDoDefaultAction( | |
| 811 AccObjectMatcher(L"Save", L"push button"), | |
| 812 1000)) | |
| 813 .WillOnce(testing::Return()); | |
| 814 | |
| 815 EXPECT_CALL(download_watcher, OnWindowClose(_)) | |
| 816 .Times(testing::AnyNumber()); | |
| 817 | |
| 818 std::wstring src_url = server_mock_.Resolve(L"/post_source.html"); | |
| 819 std::wstring tgt_url = server_mock_.Resolve(L"/post_target.html"); | |
| 820 | |
| 821 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 822 | |
| 823 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, | |
| 824 testing::Field(&VARIANT::bstrVal, | |
| 825 StrEq(src_url)), _, _, _, _, _)); | |
| 826 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 827 testing::Field(&VARIANT::bstrVal, | |
| 828 StrEq(src_url)))); | |
| 829 EXPECT_CALL(ie_mock_, OnLoad(true, StrEq(src_url))) | |
| 830 .Times(testing::AnyNumber()); | |
| 831 | |
| 832 ie_mock_.ExpectNewWindow(&download_window_mock); | |
| 833 EXPECT_CALL(ie_mock_, OnLoadError(StrEq(tgt_url))) | |
| 834 .Times(testing::AnyNumber()); | |
| 835 | |
| 836 EXPECT_CALL(download_window_mock, OnFileDownload(_, _)) | |
| 837 .Times(testing::AnyNumber()); | |
| 838 EXPECT_CALL(download_window_mock, OnLoadError(StrEq(tgt_url))) | |
| 839 .Times(testing::AtMost(1)); | |
| 840 EXPECT_CALL(download_window_mock, OnBeforeNavigate2(_, | |
| 841 testing::Field(&VARIANT::bstrVal, | |
| 842 StrEq(tgt_url)), _, _, _, _, _)); | |
| 843 EXPECT_CALL(download_window_mock, OnLoad(false, _)); | |
| 844 EXPECT_CALL(download_window_mock, OnQuit()).Times(testing::AtMost(1)); | |
| 845 | |
| 846 base::FilePath temp_file_path; | |
| 847 ASSERT_TRUE(base::CreateTemporaryFile(&temp_file_path)); | |
| 848 file_util::DieFileDie(temp_file_path, false); | |
| 849 | |
| 850 temp_file_path = temp_file_path.ReplaceExtension(L"txt"); | |
| 851 file_util::DieFileDie(temp_file_path, false); | |
| 852 | |
| 853 AccObjectMatcher file_name_box(L"File name:", L"editable text"); | |
| 854 | |
| 855 HWND owner_window = NULL; | |
| 856 | |
| 857 EXPECT_CALL(save_dialog_watcher, OnWindowOpen(_)) | |
| 858 .WillOnce(testing::DoAll( | |
| 859 testing::Invoke(testing::CreateFunctor( | |
| 860 SaveOwnerWindow, &owner_window)), | |
| 861 AccSendCharMessage(file_name_box, L'a'), | |
| 862 AccSetValue(file_name_box, temp_file_path.value()), | |
| 863 AccDoDefaultAction(AccObjectMatcher(L"Save", L"push button")))); | |
| 864 | |
| 865 EXPECT_CALL(save_dialog_watcher, OnWindowClose(_)) | |
| 866 .WillOnce(testing::DoAll( | |
| 867 WaitForFileSave(temp_file_path, 3000), | |
| 868 testing::InvokeWithoutArgs( | |
| 869 testing::CreateFunctor(CloseWindow, &owner_window)), | |
| 870 CloseBrowserMock(&ie_mock_))); | |
| 871 LaunchIENavigateAndLoop(src_url, kChromeFrameVeryLongNavigationTimeout); | |
| 872 | |
| 873 std::string data; | |
| 874 EXPECT_TRUE(base::ReadFileToString(temp_file_path, &data)); | |
| 875 EXPECT_EQ("hello", data); | |
| 876 file_util::DieFileDie(temp_file_path, false); | |
| 877 } | |
| 878 | |
| 879 // Test fixture for testing if http header works for supported content types | |
| 880 class HttpHeaderTest : public MockIEEventSinkTest, public testing::Test { | |
| 881 public: | |
| 882 HttpHeaderTest() {} | |
| 883 | |
| 884 void HeaderTestWithData(const char* content_type, const char* data) { | |
| 885 const wchar_t* relative_url = L"/header_test"; | |
| 886 const char* kHeaderFormat = | |
| 887 "HTTP/1.1 200 OK\r\n" | |
| 888 "Connection: close\r\n" | |
| 889 "Content-Type: %s\r\n" | |
| 890 "X-UA-Compatible: chrome=1\r\n"; | |
| 891 std::string header = base::StringPrintf(kHeaderFormat, content_type); | |
| 892 std::wstring url = server_mock_.Resolve(relative_url); | |
| 893 EXPECT_CALL(server_mock_, Get(_, StrEq(relative_url), _)) | |
| 894 .WillRepeatedly(SendFast(header, data)); | |
| 895 | |
| 896 InSequence expect_in_sequence_for_scope; | |
| 897 | |
| 898 ie_mock_.ExpectNavigation(IN_CF, url); | |
| 899 EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(url))) | |
| 900 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 901 | |
| 902 LaunchIEAndNavigate(url); | |
| 903 } | |
| 904 }; | |
| 905 | |
| 906 const char* kXmlContent = | |
| 907 "<tree>" | |
| 908 "<node href=\"root.htm\" text=\"Root\">" | |
| 909 "<node href=\"child1.htm\" text=\"Child 1\" />" | |
| 910 "<node href=\"child2.htm\" text=\"Child 2\" />" | |
| 911 "</node>" | |
| 912 "</tree>"; | |
| 913 | |
| 914 TEST_F(HttpHeaderTest, ApplicationXhtml) { | |
| 915 HeaderTestWithData("application/xhtml+xml", kXmlContent); | |
| 916 } | |
| 917 | |
| 918 TEST_F(HttpHeaderTest, ApplicationXml) { | |
| 919 HeaderTestWithData("application/xml", kXmlContent); | |
| 920 } | |
| 921 | |
| 922 TEST_F(HttpHeaderTest, TextXml) { | |
| 923 HeaderTestWithData("text/xml", kXmlContent); | |
| 924 } | |
| 925 | |
| 926 const char* kImageSvg = | |
| 927 "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" " | |
| 928 "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">" | |
| 929 "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"100%\" height=\"100%\">" | |
| 930 "<rect height=\"100\" width=\"300\" " | |
| 931 "style=\"fill:rgb(0,0,255);stroke-width:2;\"/>" | |
| 932 "</svg>"; | |
| 933 | |
| 934 TEST_F(HttpHeaderTest, DISABLED_ImageSvg) { | |
| 935 HeaderTestWithData("image/svg", kImageSvg); | |
| 936 } | |
| 937 | |
| 938 TEST_F(HttpHeaderTest, ImageSvgXml) { | |
| 939 HeaderTestWithData("image/svg+xml", kImageSvg); | |
| 940 } | |
| 941 | |
| 942 // Tests refreshing causes a page load. | |
| 943 TEST_P(FullTabNavigationTest, RefreshContents) { | |
| 944 bool in_cf = GetParam().invokes_cf(); | |
| 945 if (!in_cf) { | |
| 946 VLOG(1) << "Disabled for this configuration"; | |
| 947 return; | |
| 948 } | |
| 949 | |
| 950 const char kHeaders[] = | |
| 951 "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n" | |
| 952 "X-UA-Compatible: chrome=1\r\nCache-control: no-cache\r\n"; | |
| 953 | |
| 954 const char kBody[] = "<html><body>Hi there. Got new content?" | |
| 955 "</body></html>"; | |
| 956 | |
| 957 std::wstring src_url = server_mock_.Resolve(L"/refresh_src.html"); | |
| 958 | |
| 959 EXPECT_CALL(server_mock_, Get(_, StrEq(L"/refresh_src.html"), _)) | |
| 960 .Times(2) | |
| 961 .WillRepeatedly(SendFast(kHeaders, kBody)); | |
| 962 | |
| 963 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 964 | |
| 965 EXPECT_CALL(ie_mock_, | |
| 966 OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 967 StrEq(src_url)), | |
| 968 _, _, _, _, _)); | |
| 969 EXPECT_CALL(ie_mock_, | |
| 970 OnNavigateComplete2(_, testing::Field(&VARIANT::bstrVal, | |
| 971 StrEq(src_url)))); | |
| 972 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(src_url))) | |
| 973 .Times(2) | |
| 974 .WillOnce(DelayRefresh( | |
| 975 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(50))) | |
| 976 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 977 | |
| 978 LaunchIENavigateAndLoop(src_url, kChromeFrameVeryLongNavigationTimeout); | |
| 979 } | |
| 980 | |
| 981 class FullTabSeleniumTest | |
| 982 : public MockIEEventSinkTest, public testing::TestWithParam<CFInvocation> { | |
| 983 public: | |
| 984 FullTabSeleniumTest() | |
| 985 : MockIEEventSinkTest(1337, L"127.0.0.1", GetSeleniumTestFolder()) {} | |
| 986 }; | |
| 987 | |
| 988 ACTION(VerifySeleniumCoreTestResults) { | |
| 989 int num_tests = 0; | |
| 990 int failed_tests = 0; | |
| 991 | |
| 992 swscanf(arg0, L"%d/%d", &num_tests, &failed_tests); | |
| 993 | |
| 994 // Currently we run total 505 tests and 8 steps fail. | |
| 995 // TODO(amit): send results as JSON, diagnose and eliminate failures. | |
| 996 EXPECT_LE(failed_tests, 15) << "Expected failures: " << 15 << | |
| 997 " Actual failures: " << failed_tests; | |
| 998 EXPECT_GE(num_tests, 500) << "Expected to run: " << 500 << " tests." << | |
| 999 " Actual number of tests run: " << num_tests; | |
| 1000 } | |
| 1001 | |
| 1002 // Crashes flakily: http://crbug.com/109114 | |
| 1003 // Tests refreshing causes a page load. | |
| 1004 TEST_F(FullTabSeleniumTest, DISABLED_Core) { | |
| 1005 // Please see http://code.google.com/p/chromium/issues/detail?id=60987 | |
| 1006 // for more information on why this test is disabled for Vista with IE7. | |
| 1007 if (base::win::GetVersion() == base::win::VERSION_VISTA && | |
| 1008 GetInstalledIEVersion() == IE_7) { | |
| 1009 LOG(INFO) << "Not running test on Vista with IE7"; | |
| 1010 return; | |
| 1011 } | |
| 1012 | |
| 1013 server_mock_.ExpectAndServeAnyRequests(CFInvocation::HttpHeader()); | |
| 1014 std::wstring url = GetTestUrl(L"core/TestRunner.html"); | |
| 1015 | |
| 1016 // Expectations for TestRunner.html | |
| 1017 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 1018 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, | |
| 1019 testing::Field(&VARIANT::bstrVal, | |
| 1020 testing::StartsWith(url)), _, _, _, _, _)) | |
| 1021 .Times(testing::AnyNumber()); | |
| 1022 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 1023 testing::Field(&VARIANT::bstrVal, | |
| 1024 testing::StartsWith(url)))) | |
| 1025 .Times(testing::AnyNumber()); | |
| 1026 EXPECT_CALL(ie_mock_, OnLoad(true, testing::StartsWith(url))) | |
| 1027 .Times(testing::AnyNumber()); | |
| 1028 | |
| 1029 // Expectation for cookie test | |
| 1030 EXPECT_CALL(ie_mock_, OnLoadError(testing::StartsWith(url))) | |
| 1031 .Times(testing::AtMost(3)); | |
| 1032 | |
| 1033 // Expectations for popups | |
| 1034 std::wstring attach_url_prefix = GetTestUrl(L"?attach_external_tab&"); | |
| 1035 EXPECT_CALL(ie_mock_, OnNewWindow3(_, _, _, _, | |
| 1036 testing::StartsWith(attach_url_prefix))) | |
| 1037 .Times(testing::AnyNumber()); | |
| 1038 EXPECT_CALL(ie_mock_, OnNewBrowserWindow(_, | |
| 1039 testing::StartsWith(attach_url_prefix))) | |
| 1040 .Times(testing::AnyNumber()); | |
| 1041 | |
| 1042 // At the end the tests will post us a message. See _onTestSuiteComplete in | |
| 1043 // ...\src\data\selenium_core\core\scripts\selenium-testrunner.js | |
| 1044 EXPECT_CALL(ie_mock_, OnMessage(_, _, _)) | |
| 1045 .WillOnce(testing::DoAll(VerifySeleniumCoreTestResults(), | |
| 1046 CloseBrowserMock(&ie_mock_))); | |
| 1047 | |
| 1048 // Selenium tests take longer to finish, lets give it 2 mins. | |
| 1049 const base::TimeDelta kSeleniumTestTimeout = base::TimeDelta::FromMinutes(2); | |
| 1050 LaunchIENavigateAndLoop(url, kSeleniumTestTimeout); | |
| 1051 } | |
| 1052 | |
| 1053 // See bug http://code.google.com/p/chromium/issues/detail?id=64901 | |
| 1054 // This test does the following:- | |
| 1055 // Navigates IE to a non ChromeFrame URL. | |
| 1056 // Performs a top level form post in the document | |
| 1057 // In response to the POST send over a html document containing a meta tag | |
| 1058 // This would cause IE to switch to ChromeFrame. | |
| 1059 // Refresh the page in ChromeFrame. | |
| 1060 // This should bring up a confirmation dialog which we hit yes on. This should | |
| 1061 // reissue the top level post request in response to which the html content | |
| 1062 // containing the meta tag is sent again. | |
| 1063 TEST_F(FullTabDownloadTest, TopLevelPostReissueFromChromeFramePage) { | |
| 1064 chrome_frame_test::MockWindowObserver post_reissue_watcher; | |
| 1065 post_reissue_watcher.WatchWindow("Confirm Form Resubmission", ""); | |
| 1066 | |
| 1067 EXPECT_CALL(server_mock_, Get(_, StrEq(L"/post_source.html"), _)) | |
| 1068 .WillOnce(SendFast( | |
| 1069 "HTTP/1.1 200 OK\r\n" | |
| 1070 "Content-Type: text/html\r\n", | |
| 1071 "<html>" | |
| 1072 "<head>" | |
| 1073 " <script type=\"text/javascript\">" | |
| 1074 " function onLoad() {" | |
| 1075 " document.getElementById(\"myform\").submit();}</script></head>" | |
| 1076 " <body onload=\"setTimeout(onLoad, 2000);\">" | |
| 1077 " <form id=\"myform\" action=\"post_target.html\" method=\"POST\">" | |
| 1078 "</form></body></html>")); | |
| 1079 | |
| 1080 EXPECT_CALL(server_mock_, Post(_, StrEq(L"/post_target.html"), _)) | |
| 1081 .Times(2) | |
| 1082 .WillRepeatedly( | |
| 1083 SendFast( | |
| 1084 "HTTP/1.1 200 OK\r\n" | |
| 1085 "Content-Type: text/html\r\n", | |
| 1086 "<html>" | |
| 1087 "<head><meta http-equiv=\"x-ua-compatible\" content=\"chrome=1\" />" | |
| 1088 "</head>" | |
| 1089 "<body> Target page in ChromeFrame </body>" | |
| 1090 "</html>")); | |
| 1091 | |
| 1092 EXPECT_CALL(post_reissue_watcher, OnWindowOpen(_)) | |
| 1093 .WillOnce(DelayAccDoDefaultAction( | |
| 1094 AccObjectMatcher(L"Yes", L"push button"), | |
| 1095 1000)); | |
| 1096 | |
| 1097 EXPECT_CALL(post_reissue_watcher, OnWindowClose(_)); | |
| 1098 | |
| 1099 std::wstring src_url = server_mock_.Resolve(L"/post_source.html"); | |
| 1100 std::wstring tgt_url = server_mock_.Resolve(L"/post_target.html"); | |
| 1101 | |
| 1102 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 1103 | |
| 1104 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, | |
| 1105 testing::Field(&VARIANT::bstrVal, | |
| 1106 StrEq(src_url)), _, _, _, _, _)); | |
| 1107 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 1108 testing::Field(&VARIANT::bstrVal, | |
| 1109 StrEq(src_url)))); | |
| 1110 EXPECT_CALL(ie_mock_, OnLoad(false, StrEq(src_url))); | |
| 1111 | |
| 1112 EXPECT_CALL(ie_mock_, OnLoad(true, StrEq(tgt_url))) | |
| 1113 .Times(2) | |
| 1114 .WillOnce(DelayRefresh( | |
| 1115 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(50))) | |
| 1116 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 1117 | |
| 1118 EXPECT_CALL(ie_mock_, OnBeforeNavigate2(_, | |
| 1119 testing::Field(&VARIANT::bstrVal, | |
| 1120 StrEq(tgt_url)), _, _, _, _, _)) | |
| 1121 .Times(2); | |
| 1122 | |
| 1123 EXPECT_CALL(ie_mock_, OnNavigateComplete2(_, | |
| 1124 testing::Field(&VARIANT::bstrVal, | |
| 1125 StrEq(tgt_url)))) | |
| 1126 .Times(2); | |
| 1127 | |
| 1128 LaunchIENavigateAndLoop(src_url, kChromeFrameVeryLongNavigationTimeout); | |
| 1129 } | |
| 1130 | |
| 1131 MATCHER_P(UserAgentHeaderMatcher, ua_string, "") { | |
| 1132 std::string headers = arg.headers(); | |
| 1133 StringToUpperASCII(&headers); | |
| 1134 | |
| 1135 std::string ua_string_to_search = ua_string; | |
| 1136 StringToUpperASCII(&ua_string_to_search); | |
| 1137 | |
| 1138 net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), | |
| 1139 "\r\n"); | |
| 1140 while (it.GetNext()) { | |
| 1141 if (lstrcmpiA(it.name().c_str(), "User-Agent") == 0) { | |
| 1142 if (it.values().find(ua_string_to_search) != std::string::npos) | |
| 1143 return true; | |
| 1144 } | |
| 1145 } | |
| 1146 return false; | |
| 1147 } | |
| 1148 | |
| 1149 // Tests refreshing causes a page load and that the chrome frame user agent | |
| 1150 // string is appended to the UA in the incoming top level HTTP requests. | |
| 1151 TEST_P(FullTabNavigationTest, RefreshContentsUATest) { | |
| 1152 const char kBody[] = "<html><head></head>" | |
| 1153 "<body>Hi there. Got new content?" | |
| 1154 "</body></html>"; | |
| 1155 | |
| 1156 std::string headers = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n" | |
| 1157 "Cache-control: no-cache\r\n"; | |
| 1158 bool in_cf = GetParam().invokes_cf(); | |
| 1159 if (in_cf) { | |
| 1160 headers.append("X-UA-Compatible: chrome=1\r\n"); | |
| 1161 } else { | |
| 1162 if (GetInstalledIEVersion() == IE_9) { | |
| 1163 LOG(ERROR) << "Test disabled for IE9"; | |
| 1164 return; | |
| 1165 } | |
| 1166 } | |
| 1167 | |
| 1168 std::wstring src_url = server_mock_.Resolve(L"/refresh_src.html"); | |
| 1169 | |
| 1170 if (in_cf) { | |
| 1171 // In the case of Chrome Frame, end the test when the second OnLoad is | |
| 1172 // fired. | |
| 1173 EXPECT_CALL(server_mock_, Get(_, StrEq(L"/refresh_src.html"), | |
| 1174 UserAgentHeaderMatcher("chromeframe"))) | |
| 1175 .Times(2) | |
| 1176 .WillRepeatedly(SendFast(headers, kBody)); | |
| 1177 } else { | |
| 1178 // In the case of IE, we never receive a second OnLoad event, so end the | |
| 1179 // test when the second request is made on the server. | |
| 1180 EXPECT_CALL(server_mock_, Get(_, StrEq(L"/refresh_src.html"), | |
| 1181 UserAgentHeaderMatcher("chromeframe"))) | |
| 1182 .Times(2) | |
| 1183 .WillOnce(SendFast(headers, kBody)) | |
| 1184 .WillOnce(testing::DoAll( | |
| 1185 SendFast(headers, kBody), | |
| 1186 CloseBrowserMock(&ie_mock_))); | |
| 1187 } | |
| 1188 | |
| 1189 EXPECT_CALL(ie_mock_, OnFileDownload(_, _)).Times(testing::AnyNumber()); | |
| 1190 | |
| 1191 EXPECT_CALL(ie_mock_, | |
| 1192 OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 1193 StrEq(src_url)), | |
| 1194 _, _, _, _, _)); | |
| 1195 EXPECT_CALL(ie_mock_, | |
| 1196 OnNavigateComplete2(_, testing::Field(&VARIANT::bstrVal, | |
| 1197 StrEq(src_url)))); | |
| 1198 if (in_cf) { | |
| 1199 // As mentioned above, end the test once the refreshed document is loaded. | |
| 1200 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(src_url))) | |
| 1201 .Times(2) | |
| 1202 .WillOnce(DelayRefresh( | |
| 1203 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(50))) | |
| 1204 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 1205 } else { | |
| 1206 // As mentioned above, we only receive an OnLoad for the intial load, not | |
| 1207 // for the refresh. | |
| 1208 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(src_url))) | |
| 1209 .WillOnce(DelayRefresh( | |
| 1210 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(50))); | |
| 1211 } | |
| 1212 | |
| 1213 LaunchIENavigateAndLoop(src_url, kChromeFrameVeryLongNavigationTimeout); | |
| 1214 } | |
| 1215 | |
| 1216 // Link navigations in the same domain specified with the noreferrer flag | |
| 1217 // should be opened in the host browser. | |
| 1218 TEST_F(FullTabNavigationTest, JavascriptWindowOpenNoReferrerOpensInHost) { | |
| 1219 // Please see http://code.google.com/p/chromium/issues/detail?id=60987 | |
| 1220 // for more information on why this test is disabled for Vista with IE7. | |
| 1221 if (base::win::GetVersion() == base::win::VERSION_VISTA && | |
| 1222 GetInstalledIEVersion() == IE_7) { | |
| 1223 LOG(INFO) << "Not running test on Vista with IE7"; | |
| 1224 return; | |
| 1225 } | |
| 1226 | |
| 1227 MockAccEventObserver acc_observer; | |
| 1228 EXPECT_CALL(acc_observer, OnAccDocLoad(_)).Times(testing::AnyNumber()); | |
| 1229 | |
| 1230 testing::StrictMock<MockIEEventSink> new_window_mock; | |
| 1231 testing::StrictMock<MockIEEventSink> | |
| 1232 no_referrer_target_opener_window_mock; | |
| 1233 | |
| 1234 std::wstring initial_url = | |
| 1235 GetWindowOpenUrl(L"open_href_target_no_referrer.html"); | |
| 1236 | |
| 1237 std::wstring parent_url = GetTestUrl( | |
| 1238 L"open_href_target_no_referrer.html"); | |
| 1239 | |
| 1240 std::wstring new_window_url = GetSimplePageUrl(); | |
| 1241 | |
| 1242 ie_mock_.ExpectNavigation(false, initial_url); | |
| 1243 EXPECT_CALL(ie_mock_, OnLoad(false, StrEq(initial_url))); | |
| 1244 | |
| 1245 EXPECT_CALL(acc_observer, | |
| 1246 OnAccDocLoad(TabContentsTitleEq(initial_url, | |
| 1247 GetWindowOpenTitle()))) | |
| 1248 .WillOnce(AccLeftClick(AccObjectMatcher())) | |
| 1249 .RetiresOnSaturation(); | |
| 1250 | |
| 1251 ie_mock_.ExpectNewWindow(&no_referrer_target_opener_window_mock); | |
| 1252 | |
| 1253 no_referrer_target_opener_window_mock.ExpectNavigation(true, parent_url); | |
| 1254 | |
| 1255 server_mock_.ExpectAndServeRequest(CFInvocation::MetaTag(), parent_url); | |
| 1256 server_mock_.ExpectAndServeRequest(CFInvocation::None(), new_window_url); | |
| 1257 server_mock_.ExpectAndServeRequest(CFInvocation::None(), initial_url); | |
| 1258 | |
| 1259 EXPECT_CALL(no_referrer_target_opener_window_mock, | |
| 1260 OnLoad(false, StrEq(parent_url))) | |
| 1261 .Times(testing::AnyNumber()); | |
| 1262 | |
| 1263 EXPECT_CALL(no_referrer_target_opener_window_mock, | |
| 1264 OnLoad(true, StrEq(parent_url))) | |
| 1265 .WillOnce(DelayAccDoDefaultActionInRenderer( | |
| 1266 &no_referrer_target_opener_window_mock, | |
| 1267 AccObjectMatcher(L"", L"link"), 1000)); | |
| 1268 | |
| 1269 // The parent window is in CF and opens a child window with the no referrer | |
| 1270 // flag in which case it should open in IE. | |
| 1271 no_referrer_target_opener_window_mock.ExpectNewWindow(&new_window_mock); | |
| 1272 new_window_mock.ExpectNavigation(false, new_window_url); | |
| 1273 | |
| 1274 EXPECT_CALL(new_window_mock, OnFileDownload(_, _)) | |
| 1275 .Times(testing::AnyNumber()); | |
| 1276 | |
| 1277 EXPECT_CALL(new_window_mock, | |
| 1278 OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal, | |
| 1279 testing::HasSubstr(L"attach")), | |
| 1280 _, _, _, _, _)); | |
| 1281 EXPECT_CALL(new_window_mock, | |
| 1282 OnNavigateComplete2(_, testing::Field(&VARIANT::bstrVal, | |
| 1283 testing::HasSubstr(L"attach")))) | |
| 1284 .Times(testing::AtMost(1)); | |
| 1285 | |
| 1286 EXPECT_CALL(new_window_mock, OnLoad(false, StrEq(new_window_url))) | |
| 1287 .WillOnce(CloseBrowserMock(&new_window_mock)); | |
| 1288 | |
| 1289 EXPECT_CALL(new_window_mock, OnQuit()) | |
| 1290 .WillOnce(CloseBrowserMock( | |
| 1291 &no_referrer_target_opener_window_mock)); | |
| 1292 | |
| 1293 EXPECT_CALL(no_referrer_target_opener_window_mock, OnQuit()) | |
| 1294 .WillOnce(CloseBrowserMock(&ie_mock_)); | |
| 1295 | |
| 1296 LaunchIENavigateAndLoop(initial_url, kChromeFrameVeryLongNavigationTimeout); | |
| 1297 } | |
| 1298 | |
| 1299 } // namespace chrome_frame_test | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src