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.
8 #include "base/file_util.h"
9 #include "base/strings/utf_string_conversions.h"
10 #include "base/test/test_file_util.h"
11 #include "base/win/scoped_bstr.h"
12 #include "base/win/scoped_variant.h"
13 #include "base/win/windows_version.h"
14 #include "chrome/common/url_constants.h"
15 #include "chrome_frame/test/chrome_frame_test_utils.h"
16 #include "chrome_frame/test/chrome_frame_ui_test_utils.h"
17 #include "chrome_frame/test/mock_ie_event_sink_actions.h"
18 #include "chrome_frame/test/mock_ie_event_sink_test.h"
19 #include "chrome_frame/test/simulate_input.h"
21 #include "testing/gmock_mutant.h"
24 using testing::InSequence;
25 using testing::StrCaseEq;
28 namespace chrome_frame_test {
30 // This parameterized test fixture uses the MockIEEventSink and is used by
32 class FullTabUITest : public MockIEEventSinkTest,
33 public testing::TestWithParam<CFInvocation> {
37 virtual void SetUp() {
40 // These are UI-related tests, so we do not care about the exact requests
41 // and navigations that occur.
42 server_mock_.ExpectAndServeAnyRequests(GetParam());
43 ie_mock_.ExpectAnyNavigations();
46 virtual void TearDown() {
50 void ResetKeyState() {
51 // Call this to reset the state of any current keyboard modifiers, as it has
52 // been observed that these tests can leave the desktop in an invalid state
53 // (e.g. thinking that the Ctrl key is held down). Send F23 as that is
54 // particularly unlikely to be used by any real application.
55 simulate_input::SendMnemonic(
57 simulate_input::CONTROL | simulate_input::SHIFT | simulate_input::ALT,
60 simulate_input::KEY_UP);
64 // Instantiate each test case for the IE case and for CF meta tag case.
65 // It does not seem too useful to also run the CF http header case since these
66 // are UI, not navigation tests.
67 INSTANTIATE_TEST_CASE_P(IE, FullTabUITest,
68 testing::Values(CFInvocation::None()));
69 INSTANTIATE_TEST_CASE_P(CF, FullTabUITest,
70 testing::Values(CFInvocation::MetaTag()));
72 // Tests keyboard input.
73 TEST_P(FullTabUITest, KeyboardInput) {
74 if (!GetParam().invokes_cf()) {
75 LOG(ERROR) << "Test not implemented for this configuration.";
78 std::wstring key_event_url = GetTestUrl(L"keyevent.html");
80 static const char input[] = "chrome";
81 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(), StrEq(key_event_url)))
82 .WillOnce(PostKeyMessagesToRenderer(&ie_mock_, input));
84 EXPECT_CALL(ie_mock_, OnMessage(StrCaseEq(UTF8ToWide(input)), _, _))
85 .WillOnce(CloseBrowserMock(&ie_mock_));
87 LaunchIEAndNavigate(key_event_url);
90 // Tests keyboard shortcuts for back and forward.
91 // http://code.google.com/p/chromium/issues/detail?id=114058
92 TEST_P(FullTabUITest, DISABLED_KeyboardBackForward) {
93 if (IsWorkstationLocked()) {
94 LOG(ERROR) << "This test cannot be run in a locked workstation.";
98 std::wstring page1 = GetSimplePageUrl();
99 std::wstring page2 = GetLinkPageUrl();
100 bool in_cf = GetParam().invokes_cf();
101 InSequence expect_in_sequence_for_scope;
103 // This test performs the following steps.
104 // 1. Launches IE and navigates to page1
105 // 2. It then navigates to page2
106 // 3. Sends the VK_BACK keystroke to IE, which should navigate back to
108 // 4. Sends the Shift + VK_BACK keystroke to IE which should navigate
110 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1)))
111 .WillOnce(Navigate(&ie_mock_, page2));
113 short bkspace = VkKeyScanA(VK_BACK); // NOLINT
114 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
115 .WillOnce(testing::DoAll(
116 SetFocusToRenderer(&ie_mock_),
117 DelaySendScanCode(&loop_,
118 base::TimeDelta::FromSeconds(1),
120 simulate_input::NONE)));
122 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1)))
123 .WillOnce(testing::DoAll(
124 SetFocusToRenderer(&ie_mock_),
125 DelaySendScanCode(&loop_,
126 base::TimeDelta::FromSeconds(1),
128 simulate_input::SHIFT)));
130 EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
131 .WillOnce(CloseBrowserMock(&ie_mock_));
133 LaunchIENavigateAndLoop(page1, kChromeFrameVeryLongNavigationTimeout);
136 // Tests new window behavior with ctrl+N.
137 TEST_P(FullTabUITest, CtrlN) {
138 if (IsWorkstationLocked()) {
139 LOG(ERROR) << "This test cannot be run in a locked workstation.";
143 bool is_cf = GetParam().invokes_cf();
145 LOG(ERROR) << "Test not implemented for this configuration.";
148 // Ideally we want to use a ie_mock_ to watch for finer grained
149 // events for New Window, but for Crl+N we don't get any
150 // OnNewWindowX notifications. :(
151 MockWindowObserver win_observer_mock;
153 const char* kNewWindowTitlePattern = "*Internet Explorer*";
154 EXPECT_CALL(ie_mock_, OnLoad(is_cf, StrEq(GetSimplePageUrl())))
155 .WillOnce(testing::DoAll(
156 WatchWindow(&win_observer_mock, kNewWindowTitlePattern, ""),
157 SetFocusToRenderer(&ie_mock_),
158 DelaySendChar(&loop_,
159 base::TimeDelta::FromSeconds(1),
161 simulate_input::CONTROL)));
163 // Watch for new window. It appears that the window close message cannot be
164 // reliably delivered immediately upon receipt of the window open event.
165 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
166 .Times(testing::AtMost(2))
167 .WillOnce(CloseBrowserMock(&ie_mock_))
168 .WillOnce(testing::Return());
170 EXPECT_CALL(win_observer_mock, OnWindowClose(_))
171 .Times(testing::AtMost(2));
173 LaunchIENavigateAndLoop(GetSimplePageUrl(),
174 kChromeFrameVeryLongNavigationTimeout);
177 // Test that Ctrl+F opens the Find dialog.
178 TEST_P(FullTabUITest, CtrlF) {
179 if (IsWorkstationLocked()) {
180 LOG(ERROR) << "This test cannot be run in a locked workstation.";
184 bool is_cf = GetParam().invokes_cf();
186 LOG(ERROR) << "Test not implemented for this configuration.";
189 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
190 MockWindowObserver win_observer_mock;
191 InSequence expect_in_sequence_for_scope;
193 const char* kFindDialogCaption = "Find";
194 EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(GetSimplePageUrl())))
195 .WillOnce(testing::DoAll(
196 WatchWindow(&win_observer_mock, kFindDialogCaption, ""),
197 SetFocusToRenderer(&ie_mock_),
198 DelaySendChar(&loop_,
199 base::TimeDelta::FromMilliseconds(1500),
201 simulate_input::CONTROL)));
203 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
204 .WillOnce(CloseBrowserMock(&ie_mock_));
206 LaunchIENavigateAndLoop(GetSimplePageUrl(),
207 kChromeFrameVeryLongNavigationTimeout);
210 // Test that ctrl+r does cause a refresh.
211 TEST_P(FullTabUITest, CtrlR) {
212 if (IsWorkstationLocked()) {
213 LOG(ERROR) << "This test cannot be run in a locked workstation.";
217 EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
218 .Times(testing::AtMost(2))
219 .WillRepeatedly(SendResponse(&server_mock_, GetParam()));
221 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
222 StrEq(GetSimplePageUrl())))
223 .Times(testing::AtMost(2))
224 .WillOnce(testing::DoAll(
225 SetFocusToRenderer(&ie_mock_),
226 DelaySendChar(&loop_,
227 base::TimeDelta::FromSeconds(1),
229 simulate_input::CONTROL),
230 DelayCloseBrowserMock(
231 &loop_, base::TimeDelta::FromSeconds(4), &ie_mock_)))
232 .WillRepeatedly(testing::Return());
234 LaunchIENavigateAndLoop(GetSimplePageUrl(),
235 kChromeFrameVeryLongNavigationTimeout);
238 // Test window close with ctrl+w.
239 TEST_P(FullTabUITest, CtrlW) {
240 if (IsWorkstationLocked()) {
241 LOG(ERROR) << "This test cannot be run in a locked workstation.";
245 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
246 StrEq(GetSimplePageUrl())))
247 .WillOnce(testing::DoAll(
248 SetFocusToRenderer(&ie_mock_),
249 DelaySendChar(&loop_,
250 base::TimeDelta::FromSeconds(1),
252 simulate_input::CONTROL)));
254 LaunchIENavigateAndLoop(GetSimplePageUrl(),
255 kChromeFrameVeryLongNavigationTimeout);
258 // Test address bar navigation with Alt+d and URL.
259 // Flaky due to TypeUrlInAddressBar; see http://crbug.com/124244.
260 TEST_P(FullTabUITest, DISABLED_AltD) {
261 if (IsWorkstationLocked()) {
262 LOG(ERROR) << "This test cannot be run in a locked workstation.";
266 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
267 StrEq(GetSimplePageUrl())))
268 .WillOnce(testing::DoAll(
269 SetFocusToRenderer(&ie_mock_),
270 TypeUrlInAddressBar(&loop_,
272 base::TimeDelta::FromMilliseconds(1500))));
274 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
275 StrEq(GetLinkPageUrl())))
276 .WillOnce(CloseBrowserMock(&ie_mock_));
278 LaunchIENavigateAndLoop(GetSimplePageUrl(),
279 kChromeFrameVeryLongNavigationTimeout);
282 // Tests that the renderer has focus after navigation.
283 // Flaky, see http://crbug.com/90791 .
284 TEST_P(FullTabUITest, DISABLED_RendererHasFocus) {
285 EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
286 StrEq(GetSimplePageUrl())))
287 .WillOnce(testing::DoAll(
288 ExpectRendererHasFocus(&ie_mock_),
289 CloseBrowserMock(&ie_mock_)));
291 LaunchIEAndNavigate(GetSimplePageUrl());
294 // Tests that view source works.
295 TEST_P(FullTabUITest, ViewSource) {
296 // Please see http://code.google.com/p/chromium/issues/detail?id=60987
297 // for more information on why this test is disabled for Vista with IE7.
298 if (base::win::GetVersion() == base::win::VERSION_VISTA &&
299 GetInstalledIEVersion() == IE_7) {
300 LOG(INFO) << "Not running test on Vista with IE7";
304 bool in_cf = GetParam().invokes_cf();
306 LOG(ERROR) << "Test not implemented for this configuration.";
309 MockIEEventSink view_source_mock;
310 view_source_mock.ExpectAnyNavigations();
311 InSequence expect_in_sequence_for_scope;
313 // After navigation invoke view soruce action using IWebBrowser2::ExecWB
314 VARIANT empty = base::win::ScopedVariant::kEmptyVariant;
315 EXPECT_CALL(ie_mock_, OnLoad(in_cf,
316 StrEq(GetSimplePageUrl())))
317 .WillOnce(DelayExecCommand(
318 &ie_mock_, &loop_, base::TimeDelta(), &CGID_MSHTML,
319 static_cast<OLECMDID>(IDM_VIEWSOURCE),
320 OLECMDEXECOPT_DONTPROMPTUSER, &empty, &empty));
322 // Expect notification for view-source window, handle new window event
323 // and attach a new ie_mock_ to the received web browser
324 std::wstring view_source_url;
325 view_source_url += UTF8ToWide(content::kViewSourceScheme);
326 view_source_url += L":";
327 view_source_url += GetSimplePageUrl();
328 std::wstring url_in_new_window = kChromeProtocolPrefix;
329 url_in_new_window += view_source_url;
331 ie_mock_.ExpectNewWindow(&view_source_mock);
332 // For some reason this happens occasionally at least on XP IE7.
333 EXPECT_CALL(view_source_mock, OnLoad(IN_IE, StrEq(url_in_new_window)))
334 .Times(testing::AtMost(1));
335 EXPECT_CALL(view_source_mock, OnLoad(in_cf, StrEq(view_source_url)))
336 .WillOnce(testing::DoAll(
337 VerifyAddressBarUrlWithGcf(&view_source_mock),
338 CloseBrowserMock(&view_source_mock)));
340 EXPECT_CALL(view_source_mock, OnQuit())
341 .Times(testing::AtMost(1))
342 .WillOnce(CloseBrowserMock(&ie_mock_));
344 LaunchIEAndNavigate(GetSimplePageUrl());
347 void NavigateToCurrentUrl(MockIEEventSink* mock) {
348 IWebBrowser2* browser = mock->event_sink()->web_browser2();
350 base::win::ScopedBstr bstr;
351 HRESULT hr = browser->get_LocationURL(bstr.Receive());
352 EXPECT_HRESULT_SUCCEEDED(hr);
354 DCHECK(bstr.Length());
355 VARIANT empty = base::win::ScopedVariant::kEmptyVariant;
356 hr = browser->Navigate(bstr, &empty, &empty, &empty, &empty);
357 EXPECT_HRESULT_SUCCEEDED(hr);
361 // Tests that Chrome gets re-instantiated after crash if we reload via
362 // the address bar or via a new navigation.
363 // Flaky on ie7, http://crbug.com/277406.
364 TEST_P(FullTabUITest, DISABLED_TabCrashReload) {
365 using testing::DoAll;
367 if (!GetParam().invokes_cf()) {
368 LOG(ERROR) << "Test needs CF.";
372 MockPropertyNotifySinkListener prop_listener;
373 InSequence expect_in_sequence_for_scope;
375 EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
377 ExpectRendererHasFocus(&ie_mock_),
378 ExpectDocumentReadystate(&ie_mock_, READYSTATE_COMPLETE),
379 ConnectDocPropNotifySink(&ie_mock_, &prop_listener),
380 KillChromeFrameProcesses()));
382 EXPECT_CALL(prop_listener, OnChanged(DISPID_READYSTATE))
384 ExpectDocumentReadystate(&ie_mock_, READYSTATE_UNINITIALIZED),
385 DelayNavigateToCurrentUrl(
386 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(10))));
388 EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
389 .WillOnce(CloseBrowserMock(&ie_mock_));
391 LaunchIEAndNavigate(GetSimplePageUrl());
394 // Tests if Chrome gets restarted after a crash by just refreshing the document.
395 // DISABLED as per bug http://crbug.com/99317 (one of the failures is a
396 // timeout, which marking as FLAKY or FAILS won't mask).
397 TEST_P(FullTabUITest, DISABLED_TabCrashRefresh) {
398 using testing::DoAll;
400 if (!GetParam().invokes_cf()) {
401 LOG(ERROR) << "Test needs CF.";
405 MockPropertyNotifySinkListener prop_listener;
406 InSequence expect_in_sequence_for_scope;
408 EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
410 ExpectRendererHasFocus(&ie_mock_),
411 ExpectDocumentReadystate(&ie_mock_, READYSTATE_COMPLETE),
412 ConnectDocPropNotifySink(&ie_mock_, &prop_listener),
413 KillChromeFrameProcesses()));
415 VARIANT empty = base::win::ScopedVariant::kEmptyVariant;
416 EXPECT_CALL(prop_listener, OnChanged(/*DISPID_READYSTATE*/_))
418 DisconnectDocPropNotifySink(&prop_listener),
419 ExpectDocumentReadystate(&ie_mock_, READYSTATE_UNINITIALIZED),
421 &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(10),
422 static_cast<GUID*>(NULL), OLECMDID_REFRESH, 0, &empty, &empty)));
424 EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
425 .WillOnce(CloseBrowserMock(&ie_mock_));
427 LaunchIEAndNavigate(GetSimplePageUrl());
430 // Test that window.print() on a page results in the native Windows print dialog
431 // appearing rather than Chrome's in-page print preview.
432 TEST_P(FullTabUITest, WindowPrintOpensNativePrintDialog) {
433 std::wstring window_print_url(GetTestUrl(L"window_print.html"));
434 std::wstring window_print_title(L"window.print");
436 const bool is_cf = GetParam().invokes_cf();
437 MockWindowObserver win_observer_mock;
439 // When the page is loaded, start watching for the Print dialog to appear.
440 EXPECT_CALL(ie_mock_, OnLoad(is_cf, StrEq(window_print_url)))
441 .WillOnce(WatchWindow(&win_observer_mock, "Print", ""));
443 // When the print dialog opens, close it.
444 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
445 .WillOnce(DoCloseWindow());
447 // When the print dialog closes, close the browser.
448 EXPECT_CALL(win_observer_mock, OnWindowClose(_))
449 .WillOnce(CloseBrowserMock(&ie_mock_));
451 // Launch IE and navigate to the window_print.html page, which will
452 // window.print() immediately after loading.
453 LaunchIEAndNavigate(window_print_url);
456 // Test fixture for tests related to the context menu UI. Since the context
457 // menus for CF and IE are different, these tests are not parameterized.
458 class ContextMenuTest : public MockIEEventSinkTest, public testing::Test {
460 ContextMenuTest(): kTextFieldInitValue(L"SomeInitializedTextValue") {}
462 virtual void SetUp() {
463 context_menu_page_url = GetTestUrl(L"context_menu.html");
464 context_menu_page_title = L"context menu";
465 // Clear clipboard to make sure there is no effect from previous tests.
466 SetClipboardText(L"");
467 // These are UI-related tests, so we do not care about the exact
468 // navigations that occur.
469 ie_mock_.ExpectAnyNavigations();
470 EXPECT_CALL(ie_mock_, OnLoad(_, _)).Times(testing::AnyNumber());
471 EXPECT_CALL(acc_observer_, OnAccDocLoad(_)).Times(testing::AnyNumber());
474 virtual void TearDown() {
475 // Destroy the clipboard here because it is not destroyed automatically.
479 // Common helper function for "Save xxx As" tests.
480 void DoSaveAsTest(const wchar_t* role, const wchar_t* menu_item_name,
481 const wchar_t* file_ext) {
482 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
483 MockWindowObserver win_observer_mock;
484 InSequence expect_in_sequence_for_scope;
486 // Open 'Save As' dialog.
487 string16 initial_url(GetTestUrl(L"save_as_context_menu.html"));
488 const char* kSaveDlgCaption = "Save As";
489 EXPECT_CALL(acc_observer_,
490 OnAccDocLoad(TabContentsTitleEq(initial_url,
491 L"Save As download test")))
492 .WillOnce(testing::DoAll(
493 WatchWindow(&win_observer_mock, kSaveDlgCaption, ""),
494 AccRightClick(AccObjectMatcher(L"", role))));
495 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
496 .WillOnce(AccLeftClick(AccObjectMatcher(menu_item_name)));
498 // Get safe download name using temporary file.
499 base::FilePath temp_file_path;
500 ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path));
501 ASSERT_TRUE(file_util::DieFileDie(temp_file_path, false));
502 temp_file_path = temp_file_path.ReplaceExtension(file_ext);
504 AccObjectMatcher file_name_box(L"File name:", L"editable text");
505 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
506 .WillOnce(testing::DoAll(
507 AccSendCharMessage(file_name_box, L'a'),
508 AccSetValue(file_name_box, temp_file_path.value()),
509 AccDoDefaultAction(AccObjectMatcher(L"Save", L"push button"))));
511 EXPECT_CALL(win_observer_mock, OnWindowClose(_))
512 .WillOnce(CloseWhenFileSaved(&ie_mock_, temp_file_path, 8000));
514 LaunchIENavigateAndLoop(initial_url,
515 kChromeFrameVeryLongNavigationTimeout);
516 ASSERT_TRUE(file_util::DieFileDie(temp_file_path, false));
520 // Html page that holds a text field for context menu testing.
521 std::wstring context_menu_page_url;
522 // Title of said html page.
523 std::wstring context_menu_page_title;
524 // This is the text value used to test cut/copy/paste etc.
525 const std::wstring kTextFieldInitValue;
527 testing::NiceMock<MockAccEventObserver> acc_observer_;
530 // Test reloading from the context menu.
531 TEST_F(ContextMenuTest, CFReload) {
532 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
533 InSequence expect_in_sequence_for_scope;
535 string16 initial_url(GetSimplePageUrl());
536 EXPECT_CALL(acc_observer_,
537 OnAccDocLoad(TabContentsTitleEq(initial_url,
538 GetSimplePageTitle())))
539 .WillOnce(OpenContextMenuAsync());
540 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
541 .WillOnce(AccLeftClick(AccObjectMatcher(L"Reload")));
543 EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(initial_url)))
544 .WillOnce(CloseBrowserMock(&ie_mock_));
546 LaunchIEAndNavigate(initial_url);
549 // Test view source from the context menu.
550 TEST_F(ContextMenuTest, CFViewSource) {
551 // Please see http://code.google.com/p/chromium/issues/detail?id=60987
552 // for more information on why this test is disabled for Vista with IE7.
553 if (base::win::GetVersion() == base::win::VERSION_VISTA &&
554 GetInstalledIEVersion() == IE_7) {
555 LOG(INFO) << "Not running test on Vista with IE7";
558 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
559 MockIEEventSink view_source_mock;
560 view_source_mock.ExpectAnyNavigations();
561 InSequence expect_in_sequence_for_scope;
562 string16 initial_url(GetSimplePageUrl());
564 // View the page source.
565 EXPECT_CALL(acc_observer_,
566 OnAccDocLoad(TabContentsTitleEq(initial_url,
567 GetSimplePageTitle())))
568 .WillOnce(OpenContextMenuAsync());
569 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
570 .WillOnce(AccLeftClick(AccObjectMatcher(L"View page source")));
572 // Expect notification for view-source window, handle new window event
573 // and attach a new ie_mock_ to the received web browser
574 std::wstring view_source_url;
575 view_source_url += UTF8ToWide(content::kViewSourceScheme);
576 view_source_url += L":";
577 view_source_url += initial_url;
578 std::wstring url_in_new_window = kChromeProtocolPrefix;
579 url_in_new_window += view_source_url;
581 ie_mock_.ExpectNewWindow(&view_source_mock);
582 // For some reason this happens occasionally at least on XP IE7 and Win7 IE8.
583 EXPECT_CALL(view_source_mock, OnLoad(IN_IE, StrEq(url_in_new_window)))
584 .Times(testing::AtMost(1));
585 EXPECT_CALL(view_source_mock, OnLoad(IN_CF, StrEq(view_source_url)))
586 .WillOnce(testing::DoAll(
587 VerifyAddressBarUrlWithGcf(&view_source_mock),
588 CloseBrowserMock(&view_source_mock)));
589 EXPECT_CALL(view_source_mock, OnQuit())
590 .Times(testing::AtMost(1))
591 .WillOnce(CloseBrowserMock(&ie_mock_));
593 LaunchIEAndNavigate(initial_url);
596 TEST_F(ContextMenuTest, DISABLED_CFPageInfo) {
597 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
598 MockWindowObserver win_observer_mock;
599 InSequence expect_in_sequence_for_scope;
600 string16 initial_url(GetSimplePageUrl());
602 // View page information.
603 EXPECT_CALL(acc_observer_,
604 OnAccDocLoad(TabContentsTitleEq(initial_url,
605 GetSimplePageTitle())))
606 .WillOnce(testing::DoAll(
607 WatchWindow(&win_observer_mock, "", "Chrome_WidgetWin_*"),
608 OpenContextMenuAsync()));
609 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
610 .WillOnce(AccLeftClick(AccObjectMatcher(L"View page info")));
612 EXPECT_CALL(win_observer_mock, OnWindowOpen(_)).Times(1);
613 // Expect page info dialog to pop up. Dismiss the dialog with 'Esc' key
614 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
615 .WillOnce(DoCloseWindow());
617 EXPECT_CALL(win_observer_mock, OnWindowClose(_)).Times(1);
618 EXPECT_CALL(win_observer_mock, OnWindowClose(_))
619 .WillOnce(CloseBrowserMock(&ie_mock_));
621 LaunchIEAndNavigate(initial_url);
624 TEST_F(ContextMenuTest, CFInspector) {
625 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
626 MockWindowObserver win_observer_mock;
627 InSequence expect_in_sequence_for_scope;
629 // Open developer tools.
630 // Devtools begins life with "Untitled" caption and it changes
631 // later to the 'Developer Tools - <url> form.
632 const char* kPageInfoCaptionPattern = "Untitled*";
633 string16 initial_url(GetSimplePageUrl());
634 EXPECT_CALL(acc_observer_,
635 OnAccDocLoad(TabContentsTitleEq(initial_url,
636 GetSimplePageTitle())))
637 .WillOnce(testing::DoAll(
638 WatchWindow(&win_observer_mock, kPageInfoCaptionPattern, ""),
639 OpenContextMenuAsync()));
640 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
641 .WillOnce(AccLeftClick(AccObjectMatcher(L"Inspect element")));
643 EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
644 .WillOnce(DelayDoCloseWindow(5000)); // wait to catch possible crash
645 EXPECT_CALL(win_observer_mock, OnWindowClose(_))
646 .WillOnce(CloseBrowserMock(&ie_mock_));
648 LaunchIENavigateAndLoop(initial_url,
649 kChromeFrameVeryLongNavigationTimeout);
652 // http://code.google.com/p/chromium/issues/detail?id=83114
653 TEST_F(ContextMenuTest, DISABLED_CFSavePageAs) {
654 // Please see http://code.google.com/p/chromium/issues/detail?id=60987
655 // for more information on why this test is disabled for Vista with IE7.
656 if (base::win::GetVersion() == base::win::VERSION_VISTA &&
657 GetInstalledIEVersion() == IE_7) {
658 LOG(INFO) << "Not running test on Vista with IE7";
661 ASSERT_NO_FATAL_FAILURE(DoSaveAsTest(L"", L"Save as...", L".html"));
664 // http://code.google.com/p/chromium/issues/detail?id=83114
665 TEST_F(ContextMenuTest, DISABLED_CFSaveLinkAs) {
666 // Please see http://code.google.com/p/chromium/issues/detail?id=60987
667 // for more information on why this test is disabled for Vista with IE7.
668 if (base::win::GetVersion() == base::win::VERSION_VISTA &&
669 GetInstalledIEVersion() == IE_7) {
670 LOG(INFO) << "Not running test on Vista with IE7";
673 ASSERT_NO_FATAL_FAILURE(DoSaveAsTest(L"link", L"Save link as...", L".zip"));
676 // This tests that the about:version page can be opened via the CF context menu.
677 TEST_F(ContextMenuTest, CFAboutVersionLoads) {
678 // Please see http://code.google.com/p/chromium/issues/detail?id=60987
679 // for more information on why this test is disabled for Vista with IE7.
680 if (base::win::GetVersion() == base::win::VERSION_VISTA &&
681 GetInstalledIEVersion() == IE_7) {
682 LOG(INFO) << "Not running test on Vista with IE7";
685 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
686 const wchar_t* kAboutVersionUrl = L"gcf:about:version";
687 const wchar_t* kAboutVersionWithoutProtoUrl = L"about:version";
688 MockIEEventSink new_window_mock;
689 new_window_mock.ExpectAnyNavigations();
690 InSequence expect_in_sequence_for_scope;
691 string16 initial_url(GetSimplePageUrl());
693 EXPECT_CALL(acc_observer_,
694 OnAccDocLoad(TabContentsTitleEq(initial_url,
695 GetSimplePageTitle())))
696 .WillOnce(OpenContextMenuAsync());
697 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
698 .WillOnce(AccLeftClick(AccObjectMatcher(L"About*")));
700 ie_mock_.ExpectNewWindow(&new_window_mock);
701 // For some reason this happens occasionally at least on Win7 IE8.
702 EXPECT_CALL(new_window_mock, OnLoad(IN_IE, StrEq(kAboutVersionUrl)))
703 .Times(testing::AtMost(1));
704 EXPECT_CALL(new_window_mock,
705 OnLoad(IN_CF, StrEq(kAboutVersionWithoutProtoUrl)))
706 .WillOnce(testing::DoAll(
707 VerifyAddressBarUrlWithGcf(&new_window_mock),
708 CloseBrowserMock(&new_window_mock)));
710 EXPECT_CALL(new_window_mock, OnQuit())
711 .Times(testing::AtMost(1))
712 .WillOnce(CloseBrowserMock(&ie_mock_));
714 LaunchIEAndNavigate(initial_url);
717 TEST_F(ContextMenuTest, IEOpen) {
718 server_mock_.ExpectAndServeAnyRequests(CFInvocation::None());
719 InSequence expect_in_sequence_for_scope;
720 string16 initial_url(GetLinkPageUrl());
722 // Open the link through the context menu.
723 EXPECT_CALL(acc_observer_,
724 OnAccDocLoad(TabContentsTitleEq(initial_url, GetLinkPageTitle())))
725 .WillOnce(AccRightClick(AccObjectMatcher(L"", L"link")));
726 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
727 .WillOnce(AccLeftClick(AccObjectMatcher(L"Open")));
729 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl())))
730 .WillOnce(testing::DoAll(
731 VerifyAddressBarUrl(&ie_mock_),
732 CloseBrowserMock(&ie_mock_)));
734 LaunchIEAndNavigate(initial_url);
737 TEST_F(ContextMenuTest, IEOpenInNewWindow) {
738 // See crbug.com/64794.
739 if (GetInstalledIEVersion() == IE_7) {
740 LOG(INFO) << "Not running test with IE7";
743 server_mock_.ExpectAndServeAnyRequests(CFInvocation::None());
744 MockIEEventSink new_window_mock;
745 new_window_mock.ExpectAnyNavigations();
746 InSequence expect_in_sequence_for_scope;
747 string16 initial_url(GetLinkPageUrl());
749 // Open the link in a new window.
750 EXPECT_CALL(acc_observer_,
751 OnAccDocLoad(TabContentsTitleEq(initial_url, GetLinkPageTitle())))
752 .WillOnce(AccRightClick(AccObjectMatcher(L"", L"link")));
753 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
754 .WillOnce(AccLeftClick(AccObjectMatcher(L"Open in New Window")));
756 ie_mock_.ExpectNewWindow(&new_window_mock);
757 EXPECT_CALL(new_window_mock, OnLoad(IN_IE, StrEq(GetSimplePageUrl())))
758 // TODO(kkania): Verifying the address bar is flaky with this, at least
760 .WillOnce(CloseBrowserMock(&new_window_mock));
762 EXPECT_CALL(new_window_mock, OnQuit())
763 .Times(testing::AtMost(1))
764 .WillOnce(CloseBrowserMock(&ie_mock_));
766 LaunchIEAndNavigate(initial_url);
769 // Test Back/Forward from context menu.
770 TEST_F(ContextMenuTest, IEBackForward) {
771 server_mock_.ExpectAndServeAnyRequests(CFInvocation::None());
772 std::wstring page1 = GetLinkPageUrl();
773 std::wstring title1 = GetLinkPageTitle();
774 std::wstring page2 = GetSimplePageUrl();
775 std::wstring title2 = GetSimplePageTitle();
776 InSequence expect_in_sequence_for_scope;
778 // Navigate to second page.
779 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
780 .WillOnce(Navigate(&ie_mock_, page2));
783 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
784 .WillOnce(testing::DoAll(
785 VerifyPageLoad(&ie_mock_, IN_IE, page2),
786 OpenContextMenuAsync()));
787 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
788 .WillOnce(AccLeftClick(AccObjectMatcher(L"Back")));
791 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
792 .WillOnce(testing::DoAll(
793 VerifyPageLoad(&ie_mock_, IN_IE, page1),
794 OpenContextMenuAsync()));
795 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
796 .WillOnce(AccLeftClick(AccObjectMatcher(L"Forward")));
798 EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(page2)))
799 .WillOnce(CloseBrowserMock(&ie_mock_));
801 LaunchIEAndNavigate(page1);
804 // Test CF link context menu - Open link in new window.
805 // Failing intermittently on IE6/7. See crbug.com/64794.
806 TEST_F(ContextMenuTest, DISABLED_CFOpenLinkInNewWindow) {
807 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
808 MockIEEventSink new_window_mock;
809 new_window_mock.ExpectAnyNavigations();
810 string16 initial_url(GetLinkPageUrl());
812 // Invoke 'Open link in new window' context menu item.
813 EXPECT_CALL(acc_observer_,
814 OnAccDocLoad(TabContentsTitleEq(initial_url, GetLinkPageTitle())))
815 .Times(testing::AtMost(2))
816 .WillOnce(AccRightClick(AccObjectMatcher(L"", L"link")))
817 .WillOnce(testing::Return());
818 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
819 .WillOnce(AccLeftClick(AccObjectMatcher(L"Open link in new window*")));
821 ie_mock_.ExpectNewWindow(&new_window_mock);
822 EXPECT_CALL(new_window_mock, OnLoad(IN_CF, StrEq(GetSimplePageUrl())))
823 .WillOnce(CloseBrowserMock(&new_window_mock));
824 EXPECT_CALL(new_window_mock, OnQuit())
825 .WillOnce(CloseBrowserMock(&ie_mock_));
827 LaunchIEAndNavigate(initial_url);
830 // Test CF link context menu - Copy link address.
831 TEST_F(ContextMenuTest, CFCopyLinkAddress) {
832 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
833 string16 initial_url(GetLinkPageUrl());
835 // Invoke 'Copy link address' context menu item.
836 EXPECT_CALL(acc_observer_,
837 OnAccDocLoad(TabContentsTitleEq(initial_url, GetLinkPageTitle())))
838 .WillOnce(AccRightClick(AccObjectMatcher(L"", L"link")));
839 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
840 .WillOnce(testing::DoAll(
841 AccLeftClick(AccObjectMatcher(L"Copy link address*")),
842 CloseBrowserMock(&ie_mock_)));
844 LaunchIEAndNavigate(initial_url);
846 EXPECT_STREQ(GetSimplePageUrl().c_str(), GetClipboardText().c_str());
849 // Test CF text field context menu - cut.
850 // Times out sporadically http://crbug.com/119660.
851 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldCut) {
852 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
853 AccObjectMatcher txtfield_matcher(L"", L"editable text");
855 // Invoke "Cut" context menu item of text field.
856 EXPECT_CALL(acc_observer_,
857 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
858 context_menu_page_title)))
859 .WillOnce(testing::DoAll(
860 AccRightClick(txtfield_matcher),
861 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher)));
862 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
863 .WillOnce(AccLeftClick(AccObjectMatcher(L"Cut*")));
865 // Verify that text field is empty after cut operation.
866 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"")))
867 .WillOnce(CloseBrowserMock(&ie_mock_));
869 LaunchIEAndNavigate(context_menu_page_url);
870 // Verify that the text value has been cut to clipboard.
871 EXPECT_STREQ(kTextFieldInitValue.c_str(), GetClipboardText().c_str());
874 // Test CF text field context menu - copy.
875 // Times out sporadically http://crbug.com/119660.
876 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldCopy) {
877 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
878 AccObjectMatcher txtfield_matcher(L"", L"editable text");
880 // Invoke "Copy" context menu item of text field.
881 EXPECT_CALL(acc_observer_,
882 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
883 context_menu_page_title)))
884 .WillOnce(testing::DoAll(
885 AccRightClick(txtfield_matcher),
886 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher)));
887 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
888 .WillOnce(testing::DoAll(
889 AccLeftClick(AccObjectMatcher(L"Copy*")),
890 CloseBrowserMock(&ie_mock_)));
892 // Verify that there is no change on text field value after copy operation.
893 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, _))
894 .Times(testing::AtMost(0));
896 LaunchIEAndNavigate(context_menu_page_url);
897 // Verify that the text value has been copied to clipboard.
898 EXPECT_STREQ(kTextFieldInitValue.c_str(), GetClipboardText().c_str());
901 // Test CF text field context menu - paste.
902 // Times out sporadically http://crbug.com/119660.
903 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldPaste) {
904 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
905 AccObjectMatcher txtfield_matcher(L"", L"editable text");
907 // Invoke "Paste" context menu item of text field.
908 EXPECT_CALL(acc_observer_,
909 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
910 context_menu_page_title)))
911 .WillOnce(testing::DoAll(
912 AccRightClick(txtfield_matcher),
913 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher)));
914 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
915 .WillOnce(AccLeftClick(AccObjectMatcher(L"Paste*")));
916 // Verify that value has been pasted to text field.
917 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(kTextFieldInitValue)))
918 .WillOnce(CloseBrowserMock(&ie_mock_));
920 // Set some text value to clipboard, this is to emulate the 'copy' action.
921 SetClipboardText(kTextFieldInitValue);
923 LaunchIEAndNavigate(context_menu_page_url);
926 // Test CF text field context menu - delete.
927 // Times out sporadically http://crbug.com/119660.
928 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldDelete) {
929 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
930 AccObjectMatcher txtfield_matcher(L"", L"editable text");
932 // Invoke 'Delete' context menu item of text field.
933 EXPECT_CALL(acc_observer_,
934 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
935 context_menu_page_title)))
936 .WillOnce(testing::DoAll(
937 AccRightClick(txtfield_matcher),
938 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher)));
939 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
940 .WillOnce(AccLeftClick(AccObjectMatcher(L"Delete*")));
941 // Verify that value has been deleted from text field.
942 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"")))
943 .WillOnce(CloseBrowserMock(&ie_mock_));
945 LaunchIEAndNavigate(context_menu_page_url);
948 // Test CF text field context menu - select all.
949 // Flaky: http://crbug.com/144664
950 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldSelectAll) {
951 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
953 // Invoke 'Select all' context menu item of text field.
954 EXPECT_CALL(acc_observer_,
955 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
956 context_menu_page_title)))
957 .WillOnce(AccRightClick(AccObjectMatcher(L"", L"editable text")));
958 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
959 .WillOnce(testing::DoAll(
960 AccLeftClick(AccObjectMatcher(L"Select all*")),
961 PostMessageToCF(&ie_mock_, L"selectall")));
962 // Client side script verifies that the text field value has been selected,
963 // then send 'OK' message.
964 EXPECT_CALL(ie_mock_, OnMessage(testing::StrCaseEq(L"OK"), _, _))
965 .WillOnce(CloseBrowserMock(&ie_mock_));
967 LaunchIEAndNavigate(context_menu_page_url + L"?action=selectall");
970 // Test CF text field context menu - undo.
971 // Times out sporadically http://crbug.com/119660.
972 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldUndo) {
973 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
974 AccObjectMatcher txtfield_matcher(L"", L"editable text");
976 // Change the value of text field to 'A'.
977 EXPECT_CALL(acc_observer_,
978 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
979 context_menu_page_title)))
980 .WillOnce(testing::DoAll(
981 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
982 AccSendCharMessage(txtfield_matcher, L'A')));
983 // Bring up the context menu once the value has changed.
984 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"A")))
985 .WillOnce(AccRightClick(txtfield_matcher));
986 // Then select "Undo".
987 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
988 .WillOnce(testing::DoAll(
989 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
990 AccLeftClick(AccObjectMatcher(L"Undo*"))));
992 // Verify that value has been reset to initial value after undo operation.
993 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(kTextFieldInitValue)))
994 .WillOnce(CloseBrowserMock(&ie_mock_));
996 LaunchIEAndNavigate(context_menu_page_url);
999 // Test CF text field context menu - redo.
1000 // Times out sporadically http://crbug.com/119660.
1001 TEST_F(ContextMenuTest, DISABLED_CFTxtFieldRedo) {
1002 server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
1003 AccObjectMatcher txtfield_matcher(L"", L"editable text");
1004 InSequence expect_in_sequence_for_scope;
1006 // Change text field from its initial value to 'A'.
1007 EXPECT_CALL(acc_observer_,
1008 OnAccDocLoad(TabContentsTitleEq(context_menu_page_url,
1009 context_menu_page_title)))
1010 .WillOnce(testing::DoAll(
1011 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
1012 AccSendCharMessage(txtfield_matcher, L'A')));
1013 // Bring up the context menu.
1014 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"A")))
1015 .WillOnce(AccRightClick(txtfield_matcher));
1017 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1018 .WillOnce(testing::DoAll(
1019 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
1020 AccLeftClick(AccObjectMatcher(L"Undo*"))));
1022 // After undo operation is done, bring up the context menu again.
1023 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(kTextFieldInitValue)))
1024 .WillOnce(AccRightClick(txtfield_matcher));
1026 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1027 .WillOnce(testing::DoAll(
1028 AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
1029 AccLeftClick(AccObjectMatcher(L"Redo*"))));
1031 // Verify that text field value is reset to its changed value 'A' and exit.
1032 EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"A")))
1033 .WillOnce(CloseBrowserMock(&ie_mock_));
1035 LaunchIEAndNavigate(context_menu_page_url);
1038 // Disabled because it seems to hang, causing the test process to timeout and
1039 // be killed; see http://crbug.com/121097.
1040 TEST_F(ContextMenuTest, DISABLED_CFBackForward) {
1041 std::wstring page1 = GetLinkPageUrl();
1042 std::wstring title1 = GetLinkPageTitle();
1043 std::wstring page2 = GetSimplePageUrl();
1044 std::wstring title2 = GetSimplePageTitle();
1045 std::wstring page3 = GetTestUrl(L"anchor.html");
1046 std::wstring title3 = GetAnchorPageTitle();
1048 server_mock_.ExpectAndServeRequestWithCardinality(
1049 CFInvocation::MetaTag(), page1, testing::Exactly(2));
1051 server_mock_.ExpectAndServeRequestWithCardinality(
1052 CFInvocation::None(), page2, testing::Exactly(3));
1054 server_mock_.ExpectAndServeRequestWithCardinality(
1055 CFInvocation::MetaTag(), page3, testing::Exactly(2));
1057 InSequence expect_in_sequence_for_scope;
1059 // Navigate to second page.
1060 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
1061 .WillOnce(testing::DoAll(
1062 VerifyPageLoad(&ie_mock_, IN_CF, page1),
1063 Navigate(&ie_mock_, page2)));
1065 // Navigate to third page.
1066 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
1067 .WillOnce(testing::DoAll(
1068 VerifyPageLoad(&ie_mock_, IN_IE, page2),
1069 Navigate(&ie_mock_, page3)));
1072 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page3, title3)))
1073 .WillOnce(testing::DoAll(
1074 VerifyPageLoad(&ie_mock_, IN_CF, page3),
1075 OpenContextMenuAsync()));
1077 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1078 .WillOnce(AccLeftClick(AccObjectMatcher(L"Back")));
1081 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
1082 .WillOnce(testing::DoAll(
1083 VerifyPageLoad(&ie_mock_, IN_IE, page2),
1084 OpenContextMenuAsync()));
1086 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1087 .WillOnce(AccLeftClick(AccObjectMatcher(L"Back")));
1090 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
1091 .WillOnce(testing::DoAll(
1092 VerifyPageLoad(&ie_mock_, IN_CF, page1),
1093 OpenContextMenuAsync()));
1095 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1096 .WillOnce(AccLeftClick(AccObjectMatcher(L"Forward")));
1099 EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
1100 .WillOnce(testing::DoAll(
1101 VerifyPageLoad(&ie_mock_, IN_IE, page2),
1102 OpenContextMenuAsync()));
1104 EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1105 .WillOnce(AccLeftClick(AccObjectMatcher(L"Forward")));
1107 EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(page3)))
1108 .WillOnce(CloseBrowserMock(&ie_mock_));
1110 LaunchIENavigateAndLoop(page1, kChromeFrameVeryLongNavigationTimeout);
1113 } // namespace chrome_frame_test