Unit test for back/forward for url fragments. Improvements in the testing...

chrome_frame/test/chrome_frame_unittests.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include <windows.h>
 #include <stdarg.h>
 
 // IShellWindows includes.  Unfortunately we can't keep these in
 // alphabetic order since exdisp will bark if some interfaces aren't fully
 // defined.
 #include <mshtml.h>
@@ skipping 830 matching lines @@
 
 // MessageLoopForUI wrapper that runs only for a limited time.
 // We need a UI message loop in the main thread.
 struct TimedMsgLoop {
  public:
   void RunFor(int seconds) {
     QuitAfter(seconds);
     loop_.MessageLoop::Run();
   }
 
+  void PostDelayedTask(
+    const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
+      loop_.PostDelayedTask(from_here, task, delay_ms);
+  }
+
   void Quit() {
     loop_.PostTask(FROM_HERE, new MessageLoop::QuitTask);
   }
 
   void QuitAfter(int seconds) {
     loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask, 1000 * seconds);
   }
 
   MessageLoopForUI loop_;
 };
@@ skipping 353 matching lines @@
   }
 
   hr = ::CoCreateInstance(CLSID_InternetExplorer, NULL,
                           cocreate_flags, IID_IWebBrowser2,
                           reinterpret_cast<void**>(web_browser));
   // ~LowIntegrityToken() will switch integrity back to medium.
   return hr;
 }
 
 // WebBrowserEventSink member defines
+void WebBrowserEventSink::Uninitialize() {
+  chrome_frame_ = NULL;
+  if (web_browser2_.get()) {
+    DispEventUnadvise(web_browser2_);
+    web_browser2_->Quit();
+    web_browser2_.Release();
+  }
+}
+
 STDMETHODIMP WebBrowserEventSink::OnBeforeNavigate2Internal(
     IDispatch* dispatch, VARIANT* url, VARIANT* flags,
     VARIANT* target_frame_name, VARIANT* post_data, VARIANT* headers,
     VARIANT_BOOL* cancel) {
   DLOG(INFO) << __FUNCTION__;
   // Reset any existing reference to chrome frame since this is a new
   // navigation.
   chrome_frame_ = NULL;
   return OnBeforeNavigate2(dispatch, url, flags, target_frame_name,
                            post_data, headers, cancel);
@@ skipping 41 matching lines @@
   VARIANT empty = ScopedVariant::kEmptyVariant;
   ScopedVariant url;
   url.Set(navigate_url.c_str());
 
   HRESULT hr = S_OK;
   hr = web_browser2_->Navigate2(url.AsInput(), &empty, &empty, &empty, &empty);
   EXPECT_TRUE(hr == S_OK);
   return hr;
 }
 
+void WebBrowserEventSink::SetFocusToChrome() {
+  chrome_frame_test::SetKeyboardFocusToWindow(GetChromeRendererWindow(), 1, 1);
+}
+
+void WebBrowserEventSink::SendInputToChrome(
+    const std::string& input_string) {
+  chrome_frame_test::SendInputToWindow(GetChromeRendererWindow(), input_string);
+}
+
 void WebBrowserEventSink::ConnectToChromeFrame() {
   DCHECK(web_browser2_);
   ScopedComPtr<IShellBrowser> shell_browser;
   DoQueryService(SID_STopLevelBrowser, web_browser2_,
                  shell_browser.Receive());
 
   if (shell_browser) {
     ScopedComPtr<IShellView> shell_view;
     shell_browser->QueryActiveShellView(shell_view.Receive());
     if (shell_view) {
       shell_view->GetItemObject(SVGIO_BACKGROUND, __uuidof(IChromeFrame),
            reinterpret_cast<void**>(chrome_frame_.Receive()));
     }
 
     if (chrome_frame_) {
       ScopedVariant onmessage(onmessage_.ToDispatch());
       ScopedVariant onloaderror(onloaderror_.ToDispatch());
       ScopedVariant onload(onload_.ToDispatch());
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onmessage(onmessage));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onloaderror(onloaderror));
       EXPECT_HRESULT_SUCCEEDED(chrome_frame_->put_onload(onload));
     }
   }
 }
 
+HWND WebBrowserEventSink::GetChromeRendererWindow() {
+  DCHECK(chrome_frame_);
+  HWND renderer_window = NULL;
+  ScopedComPtr<IOleWindow> ole_window;
+  ole_window.QueryFrom(chrome_frame_);
+  EXPECT_TRUE(ole_window.get());
+
+  if (ole_window) {
+    HWND activex_window = NULL;
+    ole_window->GetWindow(&activex_window);
+    EXPECT_TRUE(IsWindow(activex_window));
+
+    // chrome tab window is the first (and the only) child of activex
+    HWND chrome_tab_window = GetWindow(activex_window, GW_CHILD);
+    EXPECT_TRUE(IsWindow(chrome_tab_window));
+    renderer_window = GetWindow(chrome_tab_window, GW_CHILD);
+  }
+
+  DCHECK(IsWindow(renderer_window));
+  return renderer_window;
+}
+
 const int kChromeFrameLaunchDelay = 5;
 const int kChromeFrameLongNavigationTimeoutInSeconds = 10;
 
 // This class provides functionality to add expectations to IE full tab mode
 // tests.
 class MockWebBrowserEventSink : public WebBrowserEventSink {
  public:
   // Needed to support PostTask.
   static bool ImplementsThreadSafeReferenceCounting() {
     return true;
@@ skipping 181 matching lines @@
   TimedMsgLoop loop;
 
   ASSERT_TRUE(LaunchBrowser(IE, kChromeFrameFullTabModeKeyEventUrl));
 
   // Allow some time for chrome to be launched.
   loop.RunFor(kChromeFrameLaunchDelay);
 
   HWND renderer_window = chrome_frame_test::GetChromeRendererWindow();
   EXPECT_TRUE(IsWindow(renderer_window));
 
+  chrome_frame_test::SetKeyboardFocusToWindow(renderer_window, 1, 1);
   chrome_frame_test::SendInputToWindow(renderer_window, "Chrome");
 
   loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
 
   chrome_frame_test::CloseAllIEWindows();
   ASSERT_TRUE(CheckResultFile(L"FullTab_KeyboardTest", "OK"));
 }
 
 const wchar_t kSubFrameUrl2[] =
     L"http://localhost:1337/files/sub_frame2.html";
@@ skipping 72 matching lines @@
 
   // We have reached url 1 and have 0 back & 2 forward entries for url 2 & 3
   // Go back to url 1 now
   EXPECT_CALL(mock,
               OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
                                 testing::StrCaseEq(kSubFrameUrl1)),
                                 _, _, _, _, _));
   EXPECT_CALL(mock, OnNavigateComplete2(_, _))
       .WillOnce(testing::Return());
   EXPECT_CALL(mock, OnLoad(testing::StrEq(kSubFrameUrl1)))
-      .WillOnce(QUIT_LOOP_SOON(loop, 2));
+      .WillOnce(testing::DoAll(
+          testing::InvokeWithoutArgs(CreateFunctor(&mock,
+              &WebBrowserEventSink::Uninitialize)),
+          testing::IgnoreResult(testing::InvokeWithoutArgs(
+              &chrome_frame_test::CloseAllIEWindows)),
+          QUIT_LOOP_SOON(loop, 2)));
 
   HRESULT hr = mock.LaunchIEAndNavigate(kSubFrameUrl1);
   ASSERT_HRESULT_SUCCEEDED(hr);
   if (hr == S_FALSE)
     return;
 
   ASSERT_TRUE(mock.web_browser2() != NULL);
+  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+}
 
-  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
-
-  mock.Uninitialize();
-  chrome_frame_test::CloseAllIEWindows();
-}
 
 const wchar_t kChromeFrameAboutBlankUrl[] = L"cf:about:blank";
 
 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_ChromeFrameFocusTest) {
   TimedMsgLoop loop;
 
   ASSERT_TRUE(LaunchBrowser(IE, kChromeFrameAboutBlankUrl));
 
   // Allow some time for chrome to be launched.
   loop.RunFor(kChromeFrameLaunchDelay);
 
   HWND renderer_window = chrome_frame_test::GetChromeRendererWindow();
   EXPECT_TRUE(IsWindow(renderer_window));
 
   DWORD renderer_thread_id = 0;
   DWORD renderer_process_id = 0;
   renderer_thread_id = GetWindowThreadProcessId(renderer_window,
                                                 &renderer_process_id);
 
   AttachThreadInput(GetCurrentThreadId(), renderer_thread_id, TRUE);
   HWND focus_window = GetFocus();
   EXPECT_TRUE(focus_window == renderer_window);
   AttachThreadInput(GetCurrentThreadId(), renderer_thread_id, FALSE);
 
   chrome_frame_test::CloseAllIEWindows();
 }
 
+const wchar_t kAnchorUrl[] = L"http://localhost:1337/files/anchor.html";
+const wchar_t kAnchor1Url[] = L"http://localhost:1337/files/anchor.html#a1";
+const wchar_t kAnchor2Url[] = L"http://localhost:1337/files/anchor.html#a2";
+const wchar_t kAnchor3Url[] = L"http://localhost:1337/files/anchor.html#a3";
+
+// Full tab mode back/forward test
+// Launch and navigate chrome frame to a set of URLs and test back forward
+TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_BackForwardAnchor) {
+  const char tab_enter_keystrokes[] = { VK_TAB, VK_RETURN, 0 };
+  static const std::string tab_enter(tab_enter_keystrokes);
+  TimedMsgLoop loop;
+  CComObjectStackEx<MockWebBrowserEventSink> mock;
+  ::testing::InSequence sequence;   // Everything in sequence
+
+  // Back/Forward state at this point:
+  // Back: 0
+  // Forward: 0
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchorUrl)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // Navigate to anchor 1:
+  // - First set focus to chrome renderer window
+  //   Call WebBrowserEventSink::SetFocusToChrome only once
+  //   in the beginning. Calling it again will change focus from the
+  //   current location to an element near the simulated mouse.click.
+  // - Then send keyboard input of TAB + ENTER to cause navigation.
+  //   It's better to send input as PostDelayedTask since the Activex
+  //   message loop on the other side might be blocked when we get
+  //   called in Onload.
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchorUrl)))
+      .WillOnce(testing::DoAll(
+          testing::InvokeWithoutArgs(CreateFunctor(&mock,
+              &WebBrowserEventSink::SetFocusToChrome)),
+          testing::InvokeWithoutArgs(CreateFunctor(&loop,
+              &TimedMsgLoop::PostDelayedTask, FROM_HERE, NewRunnableMethod(
+                  &mock, &WebBrowserEventSink::SendInputToChrome,
+                  std::string(tab_enter)), 0))));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor1Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // Navigate to anchor 2 after the previous navigation is complete
+  // Back/Forward state at this point:
+  // Back: 1 (kAnchorUrl)
+  // Forward: 0
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor1Url)))
+      .WillOnce(testing::InvokeWithoutArgs(
+          CreateFunctor(&loop, &TimedMsgLoop::PostDelayedTask, FROM_HERE,
+              NewRunnableMethod(&mock, &WebBrowserEventSink::SendInputToChrome,
+                  std::string(tab_enter)), 0)));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor2Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // Navigate to anchor 3 after the previous navigation is complete
+  // Back/Forward state at this point:
+  // Back: 2 (kAnchorUrl, kAnchor1Url)
+  // Forward: 0
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor2Url)))
+      .WillOnce(testing::InvokeWithoutArgs(
+          CreateFunctor(&loop, &TimedMsgLoop::PostDelayedTask, FROM_HERE,
+              NewRunnableMethod(&mock, &WebBrowserEventSink::SendInputToChrome,
+                  std::string(tab_enter)), 0)));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor3Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // We will reach anchor 3 once the navigation is complete,
+  // then go back to anchor 2
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 0
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor3Url)))
+      .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(
+          CreateFunctor(ReceivePointer(mock.web_browser2_),
+                        &IWebBrowser::GoBack))));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor2Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // We will reach anchor 2 once the navigation is complete,
+  // then go back to anchor 1
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 1 (kAnchor3Url)
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor2Url)))
+      .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(
+          CreateFunctor(ReceivePointer(mock.web_browser2_),
+                        &IWebBrowser::GoBack))));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor1Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // We will reach anchor 1 once the navigation is complete,
+  // now go forward to anchor 2
+  // Back/Forward state at this point:
+  // Back: 2 (kAnchorUrl, kAnchor1Url)
+  // Forward: 2 (kAnchor2Url, kAnchor3Url)
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor1Url)))
+      .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(
+          CreateFunctor(ReceivePointer(mock.web_browser2_),
+                        &IWebBrowser::GoForward))));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor2Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // We have reached anchor 2, go forward to anchor 3 again
+  // Back/Forward state at this point:
+  // Back: 3 (kAnchorUrl, kAnchor1Url, kAnchor2Url)
+  // Forward: 1 (kAnchor3Url)
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor2Url)))
+      .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(
+          CreateFunctor(ReceivePointer(mock.web_browser2_),
+                        &IWebBrowser::GoForward))));
+  EXPECT_CALL(mock, OnBeforeNavigate2(_, testing::Field(&VARIANT::bstrVal,
+                                      testing::StrCaseEq(kAnchor3Url)),
+                                      _, _, _, _, _))
+      .WillOnce(testing::Return(S_OK));
+  EXPECT_CALL(mock, OnNavigateComplete2(_, _))
+      .WillOnce(testing::Return());
+
+  // We have gone a few steps back and forward, this should be enough for now.
+  EXPECT_CALL(mock, OnLoad(testing::StrEq(kAnchor3Url)))
+      .WillOnce(testing::DoAll(
+          testing::InvokeWithoutArgs(CreateFunctor(&mock,
+              &WebBrowserEventSink::Uninitialize)),
+          testing::IgnoreResult(testing::InvokeWithoutArgs(
+              &chrome_frame_test::CloseAllIEWindows)),
+          QUIT_LOOP_SOON(loop, 2)));
+
+  HRESULT hr = mock.LaunchIEAndNavigate(kAnchorUrl);
+  ASSERT_HRESULT_SUCCEEDED(hr);
+  if (hr == S_FALSE)
+    return;
+
+  ASSERT_TRUE(mock.web_browser2() != NULL);
+  loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+}