| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_ | |
| 6 #define CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_ | |
| 7 | |
| 8 #include <atlbase.h> | |
| 9 #include <atlcom.h> | |
| 10 #include <string> | |
| 11 #include <vector> | |
| 12 | |
| 13 #include "base/files/file_path.h" | |
| 14 #include "base/strings/string_number_conversions.h" | |
| 15 #include "base/strings/stringprintf.h" | |
| 16 #include "base/strings/utf_string_conversions.h" | |
| 17 #include "base/win/object_watcher.h" | |
| 18 #include "chrome_frame/test/chrome_frame_test_utils.h" | |
| 19 #include "chrome_frame/test/chrome_frame_ui_test_utils.h" | |
| 20 #include "chrome_frame/test/ie_event_sink.h" | |
| 21 #include "chrome_frame/test/test_server.h" | |
| 22 #include "chrome_frame/test/test_with_web_server.h" | |
| 23 #include "chrome_frame/test/win_event_receiver.h" | |
| 24 #include "testing/gmock/include/gmock/gmock.h" | |
| 25 #include "testing/gtest/include/gtest/gtest.h" | |
| 26 #include "third_party/xulrunner-sdk/win/include/accessibility/AccessibleEventId.
h" | |
| 27 | |
| 28 namespace chrome_frame_test { | |
| 29 | |
| 30 // Convenience enum for specifying whether a load occurred in IE or CF. | |
| 31 enum LoadedInRenderer { | |
| 32 IN_IE = 0, | |
| 33 IN_CF | |
| 34 }; | |
| 35 | |
| 36 // This mocks an IEEventListener, providing methods for expecting certain | |
| 37 // sequences of events. | |
| 38 class MockIEEventSink : public IEEventListener { | |
| 39 public: | |
| 40 MockIEEventSink() { | |
| 41 CComObject<IEEventSink>::CreateInstance(&event_sink_); | |
| 42 event_sink_->AddRef(); | |
| 43 } | |
| 44 | |
| 45 ~MockIEEventSink() { | |
| 46 Detach(); | |
| 47 int reference_count = event_sink_->reference_count(); | |
| 48 LOG_IF(ERROR, reference_count != 1) | |
| 49 << "Event sink is still referenced externally: ref count = " | |
| 50 << reference_count; | |
| 51 event_sink_->Release(); | |
| 52 } | |
| 53 | |
| 54 // Override IEEventListener methods. | |
| 55 MOCK_METHOD7(OnBeforeNavigate2, void (IDispatch* dispatch, // NOLINT | |
| 56 VARIANT* url, | |
| 57 VARIANT* flags, | |
| 58 VARIANT* target_frame_name, | |
| 59 VARIANT* post_data, | |
| 60 VARIANT* headers, | |
| 61 VARIANT_BOOL* cancel)); | |
| 62 MOCK_METHOD2(OnNavigateComplete2, void (IDispatch* dispatch, // NOLINT | |
| 63 VARIANT* url)); | |
| 64 MOCK_METHOD5(OnNewWindow3, void (IDispatch** dispatch, // NOLINT | |
| 65 VARIANT_BOOL* cancel, | |
| 66 DWORD flags, | |
| 67 BSTR url_context, | |
| 68 BSTR url)); | |
| 69 MOCK_METHOD2(OnNewWindow2, void (IDispatch** dispatch, // NOLINT | |
| 70 VARIANT_BOOL* cancel)); | |
| 71 MOCK_METHOD5(OnNavigateError, void (IDispatch* dispatch, // NOLINT | |
| 72 VARIANT* url, | |
| 73 VARIANT* frame_name, | |
| 74 VARIANT* status_code, | |
| 75 VARIANT* cancel)); | |
| 76 MOCK_METHOD2(OnFileDownload, void (VARIANT_BOOL active_doc, // NOLINT | |
| 77 VARIANT_BOOL* cancel)); | |
| 78 MOCK_METHOD0(OnQuit, void ()); // NOLINT | |
| 79 MOCK_METHOD1(OnLoadError, void (const wchar_t* url)); // NOLINT | |
| 80 MOCK_METHOD3(OnMessage, void (const wchar_t* message, // NOLINT | |
| 81 const wchar_t* origin, | |
| 82 const wchar_t* source)); | |
| 83 MOCK_METHOD2(OnNewBrowserWindow, void (IDispatch* dispatch, // NOLINT | |
| 84 const wchar_t* url)); | |
| 85 | |
| 86 // Convenience OnLoad method which is called once when a page is loaded with | |
| 87 // |is_cf| set to whether the renderer is CF or not. | |
| 88 MOCK_METHOD2(OnLoad, void (bool is_cf, const wchar_t* url)); // NOLINT | |
| 89 | |
| 90 // Attach |dispatch| to the event sink and begin listening to the source's | |
| 91 // events. | |
| 92 void Attach(IDispatch* dispatch) { | |
| 93 event_sink_->set_listener(this); | |
| 94 event_sink_->Attach(dispatch); | |
| 95 } | |
| 96 | |
| 97 void Detach() { | |
| 98 event_sink_->set_listener(NULL); | |
| 99 event_sink_->Uninitialize(); | |
| 100 } | |
| 101 | |
| 102 // Expect a normal navigation to |url| to occur in CF or IE. | |
| 103 void ExpectNavigation(bool is_cf, const std::wstring& url); | |
| 104 | |
| 105 // Similar as above, but should be used in cases where IE6 with CF may not | |
| 106 // generate an OnBeforeNavigate event during the navigation. This occurs | |
| 107 // during in-page navigation (via anchors), form submission, window.open | |
| 108 // to target "self", and possibly others. | |
| 109 void ExpectNavigationOptionalBefore(bool is_cf, const std::wstring& url); | |
| 110 | |
| 111 // Expect a navigation in a new window created by a window.open call to |url|. | |
| 112 // |parent_cf| signifies whether the parent frame was loaded in CF, while | |
| 113 // |new_window_cf| signifies whether to expect the new page to be loaded in | |
| 114 // CF. | |
| 115 void ExpectJavascriptWindowOpenNavigation(bool parent_cf, bool new_window_cf, | |
| 116 const std::wstring& url); | |
| 117 | |
| 118 // Expect a new window to open. The new event sink will be attached to | |
| 119 // |new_window_mock|. | |
| 120 void ExpectNewWindow(MockIEEventSink* new_window_mock); | |
| 121 | |
| 122 // Expects any and all navigations. | |
| 123 void ExpectAnyNavigations(); | |
| 124 | |
| 125 void ExpectDocumentReadystate(int ready_state); | |
| 126 | |
| 127 IEEventSink* event_sink() { return event_sink_; } | |
| 128 | |
| 129 private: | |
| 130 // Override IE's OnDocumentComplete to call our OnLoad, iff it is IE actually | |
| 131 // rendering the page. | |
| 132 virtual void OnDocumentComplete(IDispatch* dispatch, VARIANT* url); | |
| 133 | |
| 134 // Override CF's OnLoad to call our OnLoad. | |
| 135 virtual void OnLoad(const wchar_t* url) { | |
| 136 OnLoad(IN_CF, url); | |
| 137 } | |
| 138 | |
| 139 // Helper method for expecting navigations. |before_cardinality| specifies | |
| 140 // the cardinality for the BeforeNavigate expectation and | |
| 141 // |complete_cardinality| specifies the cardinality for the NavigateComplete | |
| 142 // expectation. Returns the set of expectations added. | |
| 143 // Note: Prefer making a new Expect... method before making this public. | |
| 144 testing::ExpectationSet ExpectNavigationCardinality(const std::wstring& url, | |
| 145 testing::Cardinality before_cardinality, | |
| 146 testing::Cardinality complete_cardinality); | |
| 147 | |
| 148 // It may be necessary to create this on the heap. Otherwise, if the | |
| 149 // reference count is greater than zero, a debug assert will be triggered | |
| 150 // in the destructor. This happens at least when IE crashes. In that case, | |
| 151 // DispEventUnadvise and CoDisconnectObject are not sufficient to decrement | |
| 152 // the reference count. | |
| 153 // TODO(kkania): Investigate if the above is true. | |
| 154 CComObject<IEEventSink>* event_sink_; | |
| 155 }; | |
| 156 | |
| 157 // This mocks a PropertyNotifySinkListener, providing methods for | |
| 158 // expecting certain sequences of events. | |
| 159 class MockPropertyNotifySinkListener : public PropertyNotifySinkListener { | |
| 160 public: | |
| 161 MockPropertyNotifySinkListener() : cookie_(0), sink_(NULL) { | |
| 162 CComObject<PropertyNotifySinkImpl>::CreateInstance(&sink_); | |
| 163 sink_->AddRef(); | |
| 164 sink_->set_listener(this); | |
| 165 } | |
| 166 | |
| 167 ~MockPropertyNotifySinkListener() { | |
| 168 Detach(); | |
| 169 sink_->set_listener(NULL); | |
| 170 LOG_IF(ERROR, sink_->m_dwRef != 1) | |
| 171 << "Event sink is still referenced externally: ref count = " | |
| 172 << sink_->m_dwRef; | |
| 173 sink_->Release(); | |
| 174 } | |
| 175 | |
| 176 // Override PropertyNotifySinkListener methods. | |
| 177 MOCK_METHOD1(OnChanged, void (DISPID dispid)); // NOLINT | |
| 178 | |
| 179 bool Attach(IUnknown* obj) { | |
| 180 DCHECK_EQ(cookie_, 0UL); | |
| 181 DCHECK(obj); | |
| 182 HRESULT hr = AtlAdvise(obj, sink_->GetUnknown(), IID_IPropertyNotifySink, | |
| 183 &cookie_); | |
| 184 if (SUCCEEDED(hr)) { | |
| 185 event_source_ = obj; | |
| 186 } else { | |
| 187 LOG(ERROR) << base::StringPrintf("AtlAdvise: 0x%08X", hr); | |
| 188 cookie_ = 0; | |
| 189 } | |
| 190 | |
| 191 return SUCCEEDED(hr); | |
| 192 } | |
| 193 | |
| 194 void Detach() { | |
| 195 if (event_source_) { | |
| 196 DCHECK_NE(cookie_, 0UL); | |
| 197 AtlUnadvise(event_source_, IID_IPropertyNotifySink, cookie_); | |
| 198 event_source_.Release(); | |
| 199 cookie_ = 0; | |
| 200 } | |
| 201 } | |
| 202 | |
| 203 private: | |
| 204 CComObject<PropertyNotifySinkImpl>* sink_; | |
| 205 DWORD cookie_; | |
| 206 base::win::ScopedComPtr<IUnknown> event_source_; | |
| 207 }; | |
| 208 | |
| 209 // Allows tests to observe when processes exit. | |
| 210 class MockObjectWatcherDelegate : public base::win::ObjectWatcher::Delegate { | |
| 211 public: | |
| 212 // base::win::ObjectWatcher::Delegate implementation | |
| 213 MOCK_METHOD1(OnObjectSignaled, void (HANDLE process_handle)); // NOLINT | |
| 214 | |
| 215 virtual ~MockObjectWatcherDelegate() { | |
| 216 // Would be nice to free them when OnObjectSignaled is called, too, but | |
| 217 // it doesn't seem worth it. | |
| 218 for (std::vector<HANDLE>::iterator it = process_handles_.begin(); | |
| 219 it != process_handles_.end(); ++it) { | |
| 220 ::CloseHandle(*it); | |
| 221 } | |
| 222 } | |
| 223 | |
| 224 // Registers this instance to watch |process_handle| for termination. | |
| 225 void WatchProcess(HANDLE process_handle) { | |
| 226 process_handles_.push_back(process_handle); | |
| 227 object_watcher_.StartWatching(process_handle, this); | |
| 228 } | |
| 229 | |
| 230 // Registers this instance to watch |hwnd|'s owning process for termination. | |
| 231 void WatchProcessForHwnd(HWND hwnd) { | |
| 232 DWORD pid = 0; | |
| 233 ::GetWindowThreadProcessId(hwnd, &pid); | |
| 234 EXPECT_TRUE(pid); | |
| 235 if (pid != 0) { | |
| 236 HANDLE process_handle = ::OpenProcess(SYNCHRONIZE, FALSE, pid); | |
| 237 EXPECT_TRUE(process_handle); | |
| 238 if (process_handle != NULL) { | |
| 239 WatchProcess(process_handle); | |
| 240 } | |
| 241 } | |
| 242 } | |
| 243 | |
| 244 private: | |
| 245 std::vector<HANDLE> process_handles_; | |
| 246 base::win::ObjectWatcher object_watcher_; | |
| 247 }; | |
| 248 | |
| 249 // Mocks a window observer so that tests can detect new windows. | |
| 250 class MockWindowObserver : public WindowObserver { | |
| 251 public: | |
| 252 // WindowObserver implementation | |
| 253 MOCK_METHOD1(OnWindowOpen, void (HWND hwnd)); // NOLINT | |
| 254 MOCK_METHOD1(OnWindowClose, void (HWND hwnd)); // NOLINT | |
| 255 | |
| 256 void WatchWindow(std::string caption_pattern, std::string class_pattern) { | |
| 257 window_watcher_.AddObserver(this, caption_pattern, class_pattern); | |
| 258 } | |
| 259 | |
| 260 private: | |
| 261 WindowWatchdog window_watcher_; | |
| 262 }; | |
| 263 | |
| 264 class MockAccEventObserver : public AccEventObserver { | |
| 265 public: | |
| 266 MOCK_METHOD1(OnAccDocLoad, void (HWND)); // NOLINT | |
| 267 MOCK_METHOD3(OnAccValueChange, void (HWND, AccObject*, // NOLINT | |
| 268 const std::wstring&)); | |
| 269 MOCK_METHOD1(OnMenuPopup, void (HWND)); // NOLINT | |
| 270 MOCK_METHOD2(OnTextCaretMoved, void (HWND, AccObject*)); // NOLINT | |
| 271 }; | |
| 272 | |
| 273 // This test fixture provides common methods needed for testing CF | |
| 274 // integration with IE. gMock is used to verify that IE is reporting correct | |
| 275 // navigational events and MockWebServer is used to verify that the correct | |
| 276 // requests are going out. | |
| 277 class MockIEEventSinkTest { | |
| 278 public: | |
| 279 MockIEEventSinkTest(); | |
| 280 MockIEEventSinkTest(int port, const std::wstring& address, | |
| 281 const base::FilePath& root_dir); | |
| 282 | |
| 283 ~MockIEEventSinkTest() { | |
| 284 // Detach manually here so that it occurs before |last_resort_close_ie_| | |
| 285 // is destroyed. | |
| 286 ie_mock_.Detach(); | |
| 287 } | |
| 288 | |
| 289 // Launches IE as a COM server and sets |ie_mock_| as the event sink, then | |
| 290 // navigates to the given url. Then the timed message loop is run until | |
| 291 // |ie_mock_| receives OnQuit or the timeout is exceeded. | |
| 292 void LaunchIEAndNavigate(const std::wstring& url); | |
| 293 | |
| 294 // Same as above but allows the timeout to be specified. | |
| 295 void LaunchIENavigateAndLoop(const std::wstring& url, | |
| 296 base::TimeDelta timeout); | |
| 297 | |
| 298 // Returns the url for the test file given. |relative_path| should be | |
| 299 // relative to the test data directory. | |
| 300 std::wstring GetTestUrl(const std::wstring& relative_path); | |
| 301 | |
| 302 // Returns the absolute FilePath for the test file given. |relative_path| | |
| 303 // should be relative to the test data directory. | |
| 304 base::FilePath GetTestFilePath(const std::wstring& relative_path); | |
| 305 | |
| 306 // Returns the url for an html page just containing some text. Iff |use_cf| | |
| 307 // is true, the chrome_frame meta tag will be included too. | |
| 308 std::wstring GetSimplePageUrl() { | |
| 309 return GetTestUrl(L"simple.html"); | |
| 310 } | |
| 311 | |
| 312 // Returns the title of the html page at |GetSimplePageUrl()|. | |
| 313 std::wstring GetSimplePageTitle() { | |
| 314 return L"simple web page"; | |
| 315 } | |
| 316 | |
| 317 // Returns the url for an html page just containing one link to the simple | |
| 318 // page mentioned above. | |
| 319 std::wstring GetLinkPageUrl() { | |
| 320 return GetTestUrl(L"link.html"); | |
| 321 } | |
| 322 | |
| 323 // Returns the title of the html page at |GetLinkPageUrl()|. | |
| 324 std::wstring GetLinkPageTitle() { | |
| 325 return L"link"; | |
| 326 } | |
| 327 | |
| 328 // Returns the url for an html page containing several anchors pointing | |
| 329 // to different parts of the page. |index| specifies what fragment to | |
| 330 // append to the url. If zero, no fragment is appended. The highest fragment | |
| 331 // is #a4. | |
| 332 std::wstring GetAnchorPageUrl(int index) { | |
| 333 DCHECK_LT(index, 5); | |
| 334 std::wstring base_name = L"anchor.html"; | |
| 335 if (index > 0) | |
| 336 base_name += std::wstring(L"#a") + base::IntToString16(index); | |
| 337 return GetTestUrl(base_name); | |
| 338 } | |
| 339 | |
| 340 // Returns the title of the html page at |GetAnchorPageUrl()|. | |
| 341 std::wstring GetAnchorPageTitle() { | |
| 342 return L"Chrome Frame Test"; | |
| 343 } | |
| 344 | |
| 345 // Returns the url for an html page that will, when clicked, open a new window | |
| 346 // to |target|. | |
| 347 std::wstring GetWindowOpenUrl(const wchar_t* target) { | |
| 348 return GetTestUrl(std::wstring(L"window_open.html?").append(target)); | |
| 349 } | |
| 350 | |
| 351 // Returns the title of the html page at |GetWindowOpenUrl()|. | |
| 352 std::wstring GetWindowOpenTitle() { | |
| 353 return L"window open"; | |
| 354 } | |
| 355 | |
| 356 protected: | |
| 357 CloseIeAtEndOfScope last_resort_close_ie_; | |
| 358 chrome_frame_test::TimedMsgLoop loop_; | |
| 359 testing::StrictMock<MockIEEventSink> ie_mock_; | |
| 360 testing::StrictMock<MockWebServer> server_mock_; | |
| 361 scoped_refptr<HungCOMCallDetector> hung_call_detector_; | |
| 362 private: | |
| 363 DISALLOW_COPY_AND_ASSIGN(MockIEEventSinkTest); | |
| 364 }; | |
| 365 | |
| 366 } // namespace chrome_frame_test | |
| 367 | |
| 368 #endif // CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src