src/chrome_frame/test/ui_test.cc

   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 <mshtmcid.h>
   6 #include <string>
   7
   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"
  20
  21 #include "testing/gmock_mutant.h"
  22
  23 using testing::_;
  24 using testing::InSequence;
  25 using testing::StrCaseEq;
  26 using testing::StrEq;
  27
  28 namespace chrome_frame_test {
  29
  30 // This parameterized test fixture uses the MockIEEventSink and is used by
  31 // UI-related tests.
  32 class FullTabUITest : public MockIEEventSinkTest,
  33                       public testing::TestWithParam<CFInvocation> {
  34  public:
  35   FullTabUITest() {}
  36
  37   virtual void SetUp() {
  38     ResetKeyState();
  39
  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();
  44   }
  45
  46   virtual void TearDown() {
  47     ResetKeyState();
  48   }
  49
  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(
  56         VK_F23,
  57         simulate_input::CONTROL | simulate_input::SHIFT | simulate_input::ALT,
  58         false,
  59         false,
  60         simulate_input::KEY_UP);
  61   }
  62 };
  63
  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()));
  71
  72 // Tests keyboard input.
  73 TEST_P(FullTabUITest, KeyboardInput) {
  74   if (!GetParam().invokes_cf()) {
  75     LOG(ERROR) << "Test not implemented for this configuration.";
  76     return;
  77   }
  78   std::wstring key_event_url = GetTestUrl(L"keyevent.html");
  79
  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));
  83
  84   EXPECT_CALL(ie_mock_, OnMessage(StrCaseEq(UTF8ToWide(input)), _, _))
  85       .WillOnce(CloseBrowserMock(&ie_mock_));
  86
  87   LaunchIEAndNavigate(key_event_url);
  88 }
  89
  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.";
  95     return;
  96   }
  97
  98   std::wstring page1 = GetSimplePageUrl();
  99   std::wstring page2 = GetLinkPageUrl();
 100   bool in_cf = GetParam().invokes_cf();
 101   InSequence expect_in_sequence_for_scope;
 102
 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
 107   //    page 1
 108   // 4. Sends the Shift + VK_BACK keystroke to IE which should navigate
 109   //    forward to page2
 110   EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page1)))
 111       .WillOnce(Navigate(&ie_mock_, page2));
 112
 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),
 119                             bkspace,
 120                             simulate_input::NONE)));
 121
 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),
 127                             bkspace,
 128                             simulate_input::SHIFT)));
 129
 130   EXPECT_CALL(ie_mock_, OnLoad(in_cf, StrEq(page2)))
 131       .WillOnce(CloseBrowserMock(&ie_mock_));
 132
 133   LaunchIENavigateAndLoop(page1, kChromeFrameVeryLongNavigationTimeout);
 134 }
 135
 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.";
 140     return;
 141   }
 142
 143   bool is_cf = GetParam().invokes_cf();
 144   if (!is_cf) {
 145     LOG(ERROR) << "Test not implemented for this configuration.";
 146     return;
 147   }
 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;
 152
 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),
 160                         'n',
 161                         simulate_input::CONTROL)));
 162
 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());
 169
 170   EXPECT_CALL(win_observer_mock, OnWindowClose(_))
 171       .Times(testing::AtMost(2));
 172
 173   LaunchIENavigateAndLoop(GetSimplePageUrl(),
 174                           kChromeFrameVeryLongNavigationTimeout);
 175 }
 176
 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.";
 181     return;
 182   }
 183
 184   bool is_cf = GetParam().invokes_cf();
 185   if (!is_cf) {
 186     LOG(ERROR) << "Test not implemented for this configuration.";
 187     return;
 188   }
 189   server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
 190   MockWindowObserver win_observer_mock;
 191   InSequence expect_in_sequence_for_scope;
 192
 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),
 200                         'f',
 201                         simulate_input::CONTROL)));
 202
 203   EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
 204       .WillOnce(CloseBrowserMock(&ie_mock_));
 205
 206   LaunchIENavigateAndLoop(GetSimplePageUrl(),
 207                           kChromeFrameVeryLongNavigationTimeout);
 208 }
 209
 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.";
 214     return;
 215   }
 216
 217   EXPECT_CALL(server_mock_, Get(_, UrlPathEq(GetSimplePageUrl()), _))
 218       .Times(testing::AtMost(2))
 219       .WillRepeatedly(SendResponse(&server_mock_, GetParam()));
 220
 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),
 228                         'r',
 229                         simulate_input::CONTROL),
 230           DelayCloseBrowserMock(
 231               &loop_, base::TimeDelta::FromSeconds(4), &ie_mock_)))
 232       .WillRepeatedly(testing::Return());
 233
 234   LaunchIENavigateAndLoop(GetSimplePageUrl(),
 235                           kChromeFrameVeryLongNavigationTimeout);
 236 }
 237
 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.";
 242     return;
 243   }
 244
 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),
 251                         'w',
 252                         simulate_input::CONTROL)));
 253
 254   LaunchIENavigateAndLoop(GetSimplePageUrl(),
 255                           kChromeFrameVeryLongNavigationTimeout);
 256 }
 257
 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.";
 263     return;
 264   }
 265
 266   EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
 267                                StrEq(GetSimplePageUrl())))
 268       .WillOnce(testing::DoAll(
 269           SetFocusToRenderer(&ie_mock_),
 270           TypeUrlInAddressBar(&loop_,
 271                               GetLinkPageUrl(),
 272                               base::TimeDelta::FromMilliseconds(1500))));
 273
 274   EXPECT_CALL(ie_mock_, OnLoad(GetParam().invokes_cf(),
 275                                StrEq(GetLinkPageUrl())))
 276       .WillOnce(CloseBrowserMock(&ie_mock_));
 277
 278   LaunchIENavigateAndLoop(GetSimplePageUrl(),
 279                           kChromeFrameVeryLongNavigationTimeout);
 280 }
 281
 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_)));
 290
 291   LaunchIEAndNavigate(GetSimplePageUrl());
 292 }
 293
 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";
 301     return;
 302   }
 303
 304   bool in_cf = GetParam().invokes_cf();
 305   if (!in_cf) {
 306     LOG(ERROR) << "Test not implemented for this configuration.";
 307     return;
 308   }
 309   MockIEEventSink view_source_mock;
 310   view_source_mock.ExpectAnyNavigations();
 311   InSequence expect_in_sequence_for_scope;
 312
 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));
 321
 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;
 330
 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)));
 339
 340   EXPECT_CALL(view_source_mock, OnQuit())
 341       .Times(testing::AtMost(1))
 342       .WillOnce(CloseBrowserMock(&ie_mock_));
 343
 344   LaunchIEAndNavigate(GetSimplePageUrl());
 345 }
 346
 347 void NavigateToCurrentUrl(MockIEEventSink* mock) {
 348   IWebBrowser2* browser = mock->event_sink()->web_browser2();
 349   DCHECK(browser);
 350   base::win::ScopedBstr bstr;
 351   HRESULT hr = browser->get_LocationURL(bstr.Receive());
 352   EXPECT_HRESULT_SUCCEEDED(hr);
 353   if (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);
 358   }
 359 }
 360
 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;
 366
 367   if (!GetParam().invokes_cf()) {
 368     LOG(ERROR) << "Test needs CF.";
 369     return;
 370   }
 371
 372   MockPropertyNotifySinkListener prop_listener;
 373   InSequence expect_in_sequence_for_scope;
 374
 375   EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
 376       .WillOnce(DoAll(
 377           ExpectRendererHasFocus(&ie_mock_),
 378           ExpectDocumentReadystate(&ie_mock_, READYSTATE_COMPLETE),
 379           ConnectDocPropNotifySink(&ie_mock_, &prop_listener),
 380           KillChromeFrameProcesses()));
 381
 382   EXPECT_CALL(prop_listener, OnChanged(DISPID_READYSTATE))
 383       .WillOnce(DoAll(
 384           ExpectDocumentReadystate(&ie_mock_, READYSTATE_UNINITIALIZED),
 385           DelayNavigateToCurrentUrl(
 386               &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(10))));
 387
 388   EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
 389       .WillOnce(CloseBrowserMock(&ie_mock_));
 390
 391   LaunchIEAndNavigate(GetSimplePageUrl());
 392 }
 393
 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;
 399
 400   if (!GetParam().invokes_cf()) {
 401     LOG(ERROR) << "Test needs CF.";
 402     return;
 403   }
 404
 405   MockPropertyNotifySinkListener prop_listener;
 406   InSequence expect_in_sequence_for_scope;
 407
 408   EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
 409       .WillOnce(DoAll(
 410           ExpectRendererHasFocus(&ie_mock_),
 411           ExpectDocumentReadystate(&ie_mock_, READYSTATE_COMPLETE),
 412           ConnectDocPropNotifySink(&ie_mock_, &prop_listener),
 413           KillChromeFrameProcesses()));
 414
 415   VARIANT empty = base::win::ScopedVariant::kEmptyVariant;
 416   EXPECT_CALL(prop_listener, OnChanged(/*DISPID_READYSTATE*/_))
 417       .WillOnce(DoAll(
 418           DisconnectDocPropNotifySink(&prop_listener),
 419           ExpectDocumentReadystate(&ie_mock_, READYSTATE_UNINITIALIZED),
 420           DelayExecCommand(
 421               &ie_mock_, &loop_, base::TimeDelta::FromMilliseconds(10),
 422               static_cast<GUID*>(NULL), OLECMDID_REFRESH, 0, &empty, &empty)));
 423
 424   EXPECT_CALL(ie_mock_, OnLoad(_, StrEq(GetSimplePageUrl())))
 425       .WillOnce(CloseBrowserMock(&ie_mock_));
 426
 427   LaunchIEAndNavigate(GetSimplePageUrl());
 428 }
 429
 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");
 435
 436   const bool is_cf = GetParam().invokes_cf();
 437   MockWindowObserver win_observer_mock;
 438
 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", ""));
 442
 443   // When the print dialog opens, close it.
 444   EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
 445       .WillOnce(DoCloseWindow());
 446
 447   // When the print dialog closes, close the browser.
 448   EXPECT_CALL(win_observer_mock, OnWindowClose(_))
 449       .WillOnce(CloseBrowserMock(&ie_mock_));
 450
 451   // Launch IE and navigate to the window_print.html page, which will
 452   // window.print() immediately after loading.
 453   LaunchIEAndNavigate(window_print_url);
 454 }
 455
 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 {
 459  public:
 460   ContextMenuTest(): kTextFieldInitValue(L"SomeInitializedTextValue") {}
 461
 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());
 472   }
 473
 474   virtual void TearDown() {
 475     // Destroy the clipboard here because it is not destroyed automatically.
 476     DestroyClipboard();
 477   }
 478
 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;
 485
 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)));
 497
 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);
 503
 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"))));
 510
 511     EXPECT_CALL(win_observer_mock, OnWindowClose(_))
 512         .WillOnce(CloseWhenFileSaved(&ie_mock_, temp_file_path, 8000));
 513
 514     LaunchIENavigateAndLoop(initial_url,
 515                             kChromeFrameVeryLongNavigationTimeout);
 516     ASSERT_TRUE(file_util::DieFileDie(temp_file_path, false));
 517   }
 518
 519  protected:
 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;
 526
 527   testing::NiceMock<MockAccEventObserver> acc_observer_;
 528 };
 529
 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;
 534
 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")));
 542
 543   EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(initial_url)))
 544       .WillOnce(CloseBrowserMock(&ie_mock_));
 545
 546   LaunchIEAndNavigate(initial_url);
 547 }
 548
 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";
 556     return;
 557   }
 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());
 563
 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")));
 571
 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;
 580
 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_));
 592
 593   LaunchIEAndNavigate(initial_url);
 594 }
 595
 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());
 601
 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")));
 611
 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());
 616
 617   EXPECT_CALL(win_observer_mock, OnWindowClose(_)).Times(1);
 618   EXPECT_CALL(win_observer_mock, OnWindowClose(_))
 619     .WillOnce(CloseBrowserMock(&ie_mock_));
 620
 621   LaunchIEAndNavigate(initial_url);
 622 }
 623
 624 TEST_F(ContextMenuTest, CFInspector) {
 625   server_mock_.ExpectAndServeAnyRequests(CFInvocation::MetaTag());
 626   MockWindowObserver win_observer_mock;
 627   InSequence expect_in_sequence_for_scope;
 628
 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")));
 642
 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_));
 647
 648   LaunchIENavigateAndLoop(initial_url,
 649                           kChromeFrameVeryLongNavigationTimeout);
 650 }
 651
 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";
 659     return;
 660   }
 661   ASSERT_NO_FATAL_FAILURE(DoSaveAsTest(L"", L"Save as...", L".html"));
 662 }
 663
 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";
 671     return;
 672   }
 673   ASSERT_NO_FATAL_FAILURE(DoSaveAsTest(L"link", L"Save link as...", L".zip"));
 674 }
 675
 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";
 683     return;
 684   }
 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());
 692
 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*")));
 699
 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)));
 709
 710   EXPECT_CALL(new_window_mock, OnQuit())
 711       .Times(testing::AtMost(1))
 712       .WillOnce(CloseBrowserMock(&ie_mock_));
 713
 714   LaunchIEAndNavigate(initial_url);
 715 }
 716
 717 TEST_F(ContextMenuTest, IEOpen) {
 718   server_mock_.ExpectAndServeAnyRequests(CFInvocation::None());
 719   InSequence expect_in_sequence_for_scope;
 720   string16 initial_url(GetLinkPageUrl());
 721
 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")));
 728
 729   EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(GetSimplePageUrl())))
 730       .WillOnce(testing::DoAll(
 731           VerifyAddressBarUrl(&ie_mock_),
 732           CloseBrowserMock(&ie_mock_)));
 733
 734   LaunchIEAndNavigate(initial_url);
 735 }
 736
 737 TEST_F(ContextMenuTest, IEOpenInNewWindow) {
 738   // See crbug.com/64794.
 739   if (GetInstalledIEVersion() == IE_7) {
 740     LOG(INFO) << "Not running test with IE7";
 741     return;
 742   }
 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());
 748
 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")));
 755
 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
 759       // on XP ie6. Fix.
 760       .WillOnce(CloseBrowserMock(&new_window_mock));
 761
 762   EXPECT_CALL(new_window_mock, OnQuit())
 763       .Times(testing::AtMost(1))
 764       .WillOnce(CloseBrowserMock(&ie_mock_));
 765
 766   LaunchIEAndNavigate(initial_url);
 767 }
 768
 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;
 777
 778   // Navigate to second page.
 779   EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
 780       .WillOnce(Navigate(&ie_mock_, page2));
 781
 782   // Go back.
 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")));
 789
 790   // Go forward.
 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")));
 797
 798   EXPECT_CALL(ie_mock_, OnLoad(IN_IE, StrEq(page2)))
 799       .WillOnce(CloseBrowserMock(&ie_mock_));
 800
 801   LaunchIEAndNavigate(page1);
 802 }
 803
 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());
 811
 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*")));
 820
 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_));
 826
 827   LaunchIEAndNavigate(initial_url);
 828 }
 829
 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());
 834
 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_)));
 843
 844   LaunchIEAndNavigate(initial_url);
 845
 846   EXPECT_STREQ(GetSimplePageUrl().c_str(), GetClipboardText().c_str());
 847 }
 848
 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");
 854
 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*")));
 864
 865   // Verify that text field is empty after cut operation.
 866   EXPECT_CALL(acc_observer_, OnAccValueChange(_, _, StrEq(L"")))
 867       .WillOnce(CloseBrowserMock(&ie_mock_));
 868
 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());
 872 }
 873
 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");
 879
 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_)));
 891
 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));
 895
 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());
 899 }
 900
 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");
 906
 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_));
 919
 920   // Set some text value to clipboard, this is to emulate the 'copy' action.
 921   SetClipboardText(kTextFieldInitValue);
 922
 923   LaunchIEAndNavigate(context_menu_page_url);
 924 }
 925
 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");
 931
 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_));
 944
 945   LaunchIEAndNavigate(context_menu_page_url);
 946 }
 947
 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());
 952
 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_));
 966
 967   LaunchIEAndNavigate(context_menu_page_url + L"?action=selectall");
 968 }
 969
 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");
 975
 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*"))));
 991
 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_));
 995
 996   LaunchIEAndNavigate(context_menu_page_url);
 997 }
 998
 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;
1005
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));
1016   // Select "Undo"
1017   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1018       .WillOnce(testing::DoAll(
1019           AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
1020           AccLeftClick(AccObjectMatcher(L"Undo*"))));
1021
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));
1025   // Select "Redo"
1026   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1027       .WillOnce(testing::DoAll(
1028           AccWatchForOneValueChange(&acc_observer_, txtfield_matcher),
1029           AccLeftClick(AccObjectMatcher(L"Redo*"))));
1030
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_));
1034
1035   LaunchIEAndNavigate(context_menu_page_url);
1036 }
1037
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();
1047
1048   server_mock_.ExpectAndServeRequestWithCardinality(
1049       CFInvocation::MetaTag(), page1, testing::Exactly(2));
1050
1051   server_mock_.ExpectAndServeRequestWithCardinality(
1052       CFInvocation::None(), page2, testing::Exactly(3));
1053
1054   server_mock_.ExpectAndServeRequestWithCardinality(
1055       CFInvocation::MetaTag(), page3, testing::Exactly(2));
1056
1057   InSequence expect_in_sequence_for_scope;
1058
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)));
1064
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)));
1070
1071   // Go back.
1072   EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page3, title3)))
1073       .WillOnce(testing::DoAll(
1074           VerifyPageLoad(&ie_mock_, IN_CF, page3),
1075           OpenContextMenuAsync()));
1076
1077   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1078       .WillOnce(AccLeftClick(AccObjectMatcher(L"Back")));
1079
1080   // Go back
1081   EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
1082       .WillOnce(testing::DoAll(
1083           VerifyPageLoad(&ie_mock_, IN_IE, page2),
1084           OpenContextMenuAsync()));
1085
1086   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1087       .WillOnce(AccLeftClick(AccObjectMatcher(L"Back")));
1088
1089   // Go forward.
1090   EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page1, title1)))
1091       .WillOnce(testing::DoAll(
1092           VerifyPageLoad(&ie_mock_, IN_CF, page1),
1093           OpenContextMenuAsync()));
1094
1095   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1096       .WillOnce(AccLeftClick(AccObjectMatcher(L"Forward")));
1097
1098   // Go forward.
1099   EXPECT_CALL(acc_observer_, OnAccDocLoad(TabContentsTitleEq(page2, title2)))
1100       .WillOnce(testing::DoAll(
1101           VerifyPageLoad(&ie_mock_, IN_IE, page2),
1102           OpenContextMenuAsync()));
1103
1104   EXPECT_CALL(acc_observer_, OnMenuPopup(_))
1105       .WillOnce(AccLeftClick(AccObjectMatcher(L"Forward")));
1106
1107   EXPECT_CALL(ie_mock_, OnLoad(IN_CF, StrEq(page3)))
1108       .WillOnce(CloseBrowserMock(&ie_mock_));
1109
1110   LaunchIENavigateAndLoop(page1, kChromeFrameVeryLongNavigationTimeout);
1111 }
1112
1113 }  // namespace chrome_frame_test