OLD | NEW |
| (Empty) |
1 // Copyright 2014 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 "components/test_runner/test_runner.h" | |
6 | |
7 #include <stddef.h> | |
8 #include <limits> | |
9 #include <utility> | |
10 | |
11 #include "base/command_line.h" | |
12 #include "base/logging.h" | |
13 #include "base/macros.h" | |
14 #include "base/strings/nullable_string16.h" | |
15 #include "base/strings/string_number_conversions.h" | |
16 #include "base/strings/stringprintf.h" | |
17 #include "base/strings/utf_string_conversions.h" | |
18 #include "build/build_config.h" | |
19 #include "components/test_runner/layout_and_paint_async_then.h" | |
20 #include "components/test_runner/layout_dump.h" | |
21 #include "components/test_runner/mock_content_settings_client.h" | |
22 #include "components/test_runner/mock_credential_manager_client.h" | |
23 #include "components/test_runner/mock_screen_orientation_client.h" | |
24 #include "components/test_runner/mock_web_document_subresource_filter.h" | |
25 #include "components/test_runner/mock_web_speech_recognizer.h" | |
26 #include "components/test_runner/mock_web_user_media_client.h" | |
27 #include "components/test_runner/pixel_dump.h" | |
28 #include "components/test_runner/spell_check_client.h" | |
29 #include "components/test_runner/test_common.h" | |
30 #include "components/test_runner/test_interfaces.h" | |
31 #include "components/test_runner/test_preferences.h" | |
32 #include "components/test_runner/test_runner_for_specific_view.h" | |
33 #include "components/test_runner/web_test_delegate.h" | |
34 #include "components/test_runner/web_view_test_proxy.h" | |
35 #include "gin/arguments.h" | |
36 #include "gin/array_buffer.h" | |
37 #include "gin/handle.h" | |
38 #include "gin/object_template_builder.h" | |
39 #include "gin/wrappable.h" | |
40 #include "third_party/WebKit/public/platform/WebCanvas.h" | |
41 #include "third_party/WebKit/public/platform/WebData.h" | |
42 #include "third_party/WebKit/public/platform/WebPasswordCredential.h" | |
43 #include "third_party/WebKit/public/platform/WebPoint.h" | |
44 #include "third_party/WebKit/public/platform/WebURLResponse.h" | |
45 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDevic
eMotionData.h" | |
46 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDevic
eOrientationData.h" | |
47 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWor
kerRegistration.h" | |
48 #include "third_party/WebKit/public/web/WebArrayBuffer.h" | |
49 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h" | |
50 #include "third_party/WebKit/public/web/WebDataSource.h" | |
51 #include "third_party/WebKit/public/web/WebDocument.h" | |
52 #include "third_party/WebKit/public/web/WebFindOptions.h" | |
53 #include "third_party/WebKit/public/web/WebFrame.h" | |
54 #include "third_party/WebKit/public/web/WebInputElement.h" | |
55 #include "third_party/WebKit/public/web/WebKit.h" | |
56 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
57 #include "third_party/WebKit/public/web/WebPageImportanceSignals.h" | |
58 #include "third_party/WebKit/public/web/WebScriptSource.h" | |
59 #include "third_party/WebKit/public/web/WebSecurityPolicy.h" | |
60 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h" | |
61 #include "third_party/WebKit/public/web/WebSettings.h" | |
62 #include "third_party/WebKit/public/web/WebSurroundingText.h" | |
63 #include "third_party/WebKit/public/web/WebView.h" | |
64 #include "third_party/skia/include/core/SkBitmap.h" | |
65 #include "third_party/skia/include/core/SkCanvas.h" | |
66 #include "ui/display/display_switches.h" | |
67 #include "ui/gfx/geometry/rect.h" | |
68 #include "ui/gfx/geometry/rect_f.h" | |
69 #include "ui/gfx/geometry/size.h" | |
70 #include "ui/gfx/skia_util.h" | |
71 | |
72 #if defined(__linux__) || defined(ANDROID) | |
73 #include "third_party/WebKit/public/web/linux/WebFontRendering.h" | |
74 #endif | |
75 | |
76 using namespace blink; | |
77 | |
78 namespace test_runner { | |
79 | |
80 namespace { | |
81 | |
82 double GetDefaultDeviceScaleFactor() { | |
83 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); | |
84 if (command_line->HasSwitch(switches::kForceDeviceScaleFactor)) { | |
85 double scale; | |
86 std::string value = | |
87 command_line->GetSwitchValueASCII(switches::kForceDeviceScaleFactor); | |
88 if (base::StringToDouble(value, &scale)) | |
89 return scale; | |
90 } | |
91 return 1.f; | |
92 } | |
93 | |
94 } // namespace | |
95 | |
96 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> { | |
97 public: | |
98 static gin::WrapperInfo kWrapperInfo; | |
99 | |
100 static void Install(base::WeakPtr<TestRunner> test_runner, | |
101 base::WeakPtr<TestRunnerForSpecificView> view_test_runner, | |
102 WebLocalFrame* frame); | |
103 | |
104 private: | |
105 explicit TestRunnerBindings( | |
106 base::WeakPtr<TestRunner> test_runner, | |
107 base::WeakPtr<TestRunnerForSpecificView> view_test_runner); | |
108 ~TestRunnerBindings() override; | |
109 | |
110 // gin::Wrappable: | |
111 gin::ObjectTemplateBuilder GetObjectTemplateBuilder( | |
112 v8::Isolate* isolate) override; | |
113 | |
114 void AddMockSpeechRecognitionResult(const std::string& transcript, | |
115 double confidence); | |
116 void AddOriginAccessWhitelistEntry(const std::string& source_origin, | |
117 const std::string& destination_protocol, | |
118 const std::string& destination_host, | |
119 bool allow_destination_subdomains); | |
120 void AddWebPageOverlay(); | |
121 void CapturePixelsAsyncThen(v8::Local<v8::Function> callback); | |
122 void ClearAllDatabases(); | |
123 void ClearPrinting(); | |
124 void CloseWebInspector(); | |
125 void CopyImageAtAndCapturePixelsAsyncThen(int x, | |
126 int y, | |
127 v8::Local<v8::Function> callback); | |
128 void DidAcquirePointerLock(); | |
129 void DidLosePointerLock(); | |
130 void DidNotAcquirePointerLock(); | |
131 void DisableMockScreenOrientation(); | |
132 void DispatchBeforeInstallPromptEvent( | |
133 const std::vector<std::string>& event_platforms, | |
134 v8::Local<v8::Function> callback); | |
135 void DumpAsMarkup(); | |
136 void DumpAsText(); | |
137 void DumpAsTextWithPixelResults(); | |
138 void DumpBackForwardList(); | |
139 void DumpChildFrameScrollPositions(); | |
140 void DumpChildFramesAsMarkup(); | |
141 void DumpChildFramesAsText(); | |
142 void DumpCreateView(); | |
143 void DumpDragImage(); | |
144 void DumpEditingCallbacks(); | |
145 void DumpFrameLoadCallbacks(); | |
146 void DumpIconChanges(); | |
147 void DumpNavigationPolicy(); | |
148 void DumpPageImportanceSignals(); | |
149 void DumpPermissionClientCallbacks(); | |
150 void DumpPingLoaderCallbacks(); | |
151 void DumpResourceLoadCallbacks(); | |
152 void DumpResourceResponseMIMETypes(); | |
153 void DumpSelectionRect(); | |
154 void DumpSpellCheckCallbacks(); | |
155 void DumpTitleChanges(); | |
156 void DumpUserGestureInFrameLoadCallbacks(); | |
157 void DumpWindowStatusChanges(); | |
158 void EnableUseZoomForDSF(v8::Local<v8::Function> callback); | |
159 void EvaluateInWebInspector(int call_id, const std::string& script); | |
160 void EvaluateScriptInIsolatedWorld(int world_id, const std::string& script); | |
161 void ExecCommand(gin::Arguments* args); | |
162 void ForceNextDrawingBufferCreationToFail(); | |
163 void ForceNextWebGLContextCreationToFail(); | |
164 void ForceRedSelectionColors(); | |
165 void GetBluetoothManualChooserEvents(v8::Local<v8::Function> callback); | |
166 void GetManifestThen(v8::Local<v8::Function> callback); | |
167 void InsertStyleSheet(const std::string& source_code); | |
168 void LayoutAndPaintAsync(); | |
169 void LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback); | |
170 void LogToStderr(const std::string& output); | |
171 void NotImplemented(const gin::Arguments& args); | |
172 void NotifyDone(); | |
173 void OverridePreference(const std::string& key, v8::Local<v8::Value> value); | |
174 void QueueBackNavigation(int how_far_back); | |
175 void QueueForwardNavigation(int how_far_forward); | |
176 void QueueLoad(gin::Arguments* args); | |
177 void QueueLoadingScript(const std::string& script); | |
178 void QueueNonLoadingScript(const std::string& script); | |
179 void QueueReload(); | |
180 void RemoveOriginAccessWhitelistEntry(const std::string& source_origin, | |
181 const std::string& destination_protocol, | |
182 const std::string& destination_host, | |
183 bool allow_destination_subdomains); | |
184 void RemoveSpellCheckResolvedCallback(); | |
185 void RemoveWebPageOverlay(); | |
186 void ResetDeviceLight(); | |
187 void ResetTestHelperControllers(); | |
188 void ResolveBeforeInstallPromptPromise(const std::string& platform); | |
189 void RunIdleTasks(v8::Local<v8::Function> callback); | |
190 void SendBluetoothManualChooserEvent(const std::string& event, | |
191 const std::string& argument); | |
192 void SetAcceptLanguages(const std::string& accept_languages); | |
193 void SetAllowFileAccessFromFileURLs(bool allow); | |
194 void SetAllowRunningOfInsecureContent(bool allowed); | |
195 void SetAutoplayAllowed(bool allowed); | |
196 void SetAllowUniversalAccessFromFileURLs(bool allow); | |
197 void SetBlockThirdPartyCookies(bool block); | |
198 void SetAudioData(const gin::ArrayBufferView& view); | |
199 void SetBackingScaleFactor(double value, v8::Local<v8::Function> callback); | |
200 void SetBluetoothFakeAdapter(const std::string& adapter_name, | |
201 v8::Local<v8::Function> callback); | |
202 void SetBluetoothManualChooser(bool enable); | |
203 void SetCanOpenWindows(); | |
204 void SetCloseRemainingWindowsWhenComplete(gin::Arguments* args); | |
205 void SetColorProfile(const std::string& name, | |
206 v8::Local<v8::Function> callback); | |
207 void SetCustomPolicyDelegate(gin::Arguments* args); | |
208 void SetCustomTextOutput(const std::string& output); | |
209 void SetDatabaseQuota(int quota); | |
210 void SetDisallowedSubresourcePathSuffixes( | |
211 const std::vector<std::string>& suffixes); | |
212 void SetDomainRelaxationForbiddenForURLScheme(bool forbidden, | |
213 const std::string& scheme); | |
214 void SetDumpConsoleMessages(bool value); | |
215 void SetDumpJavaScriptDialogs(bool value); | |
216 void SetEffectiveConnectionType(const std::string& connection_type); | |
217 void SetMockSpellCheckerEnabled(bool enabled); | |
218 void SetImagesAllowed(bool allowed); | |
219 void SetIsolatedWorldContentSecurityPolicy(int world_id, | |
220 const std::string& policy); | |
221 void SetIsolatedWorldSecurityOrigin(int world_id, | |
222 v8::Local<v8::Value> origin); | |
223 void SetJavaScriptCanAccessClipboard(bool can_access); | |
224 void SetMIDIAccessorResult(bool result); | |
225 void SetMockDeviceLight(double value); | |
226 void SetMockDeviceMotion(gin::Arguments* args); | |
227 void SetMockDeviceOrientation(gin::Arguments* args); | |
228 void SetMockScreenOrientation(const std::string& orientation); | |
229 void SetMockSpeechRecognitionError(const std::string& error, | |
230 const std::string& message); | |
231 void SetPOSIXLocale(const std::string& locale); | |
232 void SetPageVisibility(const std::string& new_visibility); | |
233 void SetPermission(const std::string& name, | |
234 const std::string& value, | |
235 const std::string& origin, | |
236 const std::string& embedding_origin); | |
237 void SetPluginsAllowed(bool allowed); | |
238 void SetPluginsEnabled(bool enabled); | |
239 void SetPointerLockWillFailSynchronously(); | |
240 void SetPointerLockWillRespondAsynchronously(); | |
241 void SetPopupBlockingEnabled(bool block_popups); | |
242 void SetPrinting(); | |
243 void SetScriptsAllowed(bool allowed); | |
244 void SetShouldStayOnPageAfterHandlingBeforeUnload(bool value); | |
245 void SetSpellCheckResolvedCallback(v8::Local<v8::Function> callback); | |
246 void SetStorageAllowed(bool allowed); | |
247 void SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements); | |
248 void SetTextDirection(const std::string& direction_name); | |
249 void SetTextSubpixelPositioning(bool value); | |
250 void SetUseMockTheme(bool use); | |
251 void SetViewSourceForFrame(const std::string& name, bool enabled); | |
252 void SetWillSendRequestClearHeader(const std::string& header); | |
253 void SetWindowIsKey(bool value); | |
254 void SetXSSAuditorEnabled(bool enabled); | |
255 void ShowWebInspector(gin::Arguments* args); | |
256 void SimulateWebNotificationClick(const std::string& title, int action_index); | |
257 void SimulateWebNotificationClickWithReply(const std::string& title, | |
258 int action_index, | |
259 const std::string& reply); | |
260 void SimulateWebNotificationClose(const std::string& title, bool by_user); | |
261 void UseUnfortunateSynchronousResizeMode(); | |
262 void WaitForPolicyDelegate(); | |
263 void WaitUntilDone(); | |
264 void WaitUntilExternalURLLoad(); | |
265 void SetMockCredentialManagerError(const std::string& error); | |
266 void SetMockCredentialManagerResponse(const std::string& id, | |
267 const std::string& name, | |
268 const std::string& avatar, | |
269 const std::string& password); | |
270 void ClearMockCredentialManagerResponse(); | |
271 bool CallShouldCloseOnWebView(); | |
272 bool DisableAutoResizeMode(int new_width, int new_height); | |
273 bool EnableAutoResizeMode(int min_width, | |
274 int min_height, | |
275 int max_width, | |
276 int max_height); | |
277 std::string EvaluateInWebInspectorOverlay(const std::string& script); | |
278 v8::Local<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue( | |
279 int world_id, const std::string& script); | |
280 bool FindString(const std::string& search_text, | |
281 const std::vector<std::string>& options_array); | |
282 bool HasCustomPageSizeStyle(int page_index); | |
283 bool IsChooserShown(); | |
284 | |
285 bool IsCommandEnabled(const std::string& command); | |
286 std::string PathToLocalResource(const std::string& path); | |
287 std::string PlatformName(); | |
288 std::string SelectionAsMarkup(); | |
289 std::string TooltipText(); | |
290 | |
291 int WebHistoryItemCount(); | |
292 int WindowCount(); | |
293 | |
294 base::WeakPtr<TestRunner> runner_; | |
295 base::WeakPtr<TestRunnerForSpecificView> view_runner_; | |
296 | |
297 DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings); | |
298 }; | |
299 | |
300 gin::WrapperInfo TestRunnerBindings::kWrapperInfo = { | |
301 gin::kEmbedderNativeGin}; | |
302 | |
303 // static | |
304 void TestRunnerBindings::Install( | |
305 base::WeakPtr<TestRunner> test_runner, | |
306 base::WeakPtr<TestRunnerForSpecificView> view_test_runner, | |
307 WebLocalFrame* frame) { | |
308 v8::Isolate* isolate = blink::mainThreadIsolate(); | |
309 v8::HandleScope handle_scope(isolate); | |
310 v8::Local<v8::Context> context = frame->mainWorldScriptContext(); | |
311 if (context.IsEmpty()) | |
312 return; | |
313 | |
314 v8::Context::Scope context_scope(context); | |
315 | |
316 TestRunnerBindings* wrapped = | |
317 new TestRunnerBindings(test_runner, view_test_runner); | |
318 gin::Handle<TestRunnerBindings> bindings = | |
319 gin::CreateHandle(isolate, wrapped); | |
320 if (bindings.IsEmpty()) | |
321 return; | |
322 v8::Local<v8::Object> global = context->Global(); | |
323 v8::Local<v8::Value> v8_bindings = bindings.ToV8(); | |
324 | |
325 std::vector<std::string> names; | |
326 names.push_back("testRunner"); | |
327 names.push_back("layoutTestController"); | |
328 for (size_t i = 0; i < names.size(); ++i) | |
329 global->Set(gin::StringToV8(isolate, names[i].c_str()), v8_bindings); | |
330 } | |
331 | |
332 TestRunnerBindings::TestRunnerBindings( | |
333 base::WeakPtr<TestRunner> runner, | |
334 base::WeakPtr<TestRunnerForSpecificView> view_runner) | |
335 : runner_(runner), view_runner_(view_runner) {} | |
336 | |
337 TestRunnerBindings::~TestRunnerBindings() {} | |
338 | |
339 gin::ObjectTemplateBuilder TestRunnerBindings::GetObjectTemplateBuilder( | |
340 v8::Isolate* isolate) { | |
341 return gin::Wrappable<TestRunnerBindings>::GetObjectTemplateBuilder(isolate) | |
342 .SetMethod("abortModal", &TestRunnerBindings::NotImplemented) | |
343 .SetMethod("addDisallowedURL", &TestRunnerBindings::NotImplemented) | |
344 .SetMethod("setMockCredentialManagerError", | |
345 &TestRunnerBindings::SetMockCredentialManagerError) | |
346 .SetMethod("setMockCredentialManagerResponse", | |
347 &TestRunnerBindings::SetMockCredentialManagerResponse) | |
348 .SetMethod("clearMockCredentialManagerResponse", | |
349 &TestRunnerBindings::ClearMockCredentialManagerResponse) | |
350 .SetMethod("addMockSpeechRecognitionResult", | |
351 &TestRunnerBindings::AddMockSpeechRecognitionResult) | |
352 .SetMethod("addOriginAccessWhitelistEntry", | |
353 &TestRunnerBindings::AddOriginAccessWhitelistEntry) | |
354 .SetMethod("addWebPageOverlay", &TestRunnerBindings::AddWebPageOverlay) | |
355 .SetMethod("callShouldCloseOnWebView", | |
356 &TestRunnerBindings::CallShouldCloseOnWebView) | |
357 .SetMethod("capturePixelsAsyncThen", | |
358 &TestRunnerBindings::CapturePixelsAsyncThen) | |
359 .SetMethod("clearAllDatabases", &TestRunnerBindings::ClearAllDatabases) | |
360 .SetMethod("clearBackForwardList", &TestRunnerBindings::NotImplemented) | |
361 .SetMethod("clearPrinting", &TestRunnerBindings::ClearPrinting) | |
362 .SetMethod("closeWebInspector", &TestRunnerBindings::CloseWebInspector) | |
363 .SetMethod("copyImageAtAndCapturePixelsAsyncThen", | |
364 &TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen) | |
365 .SetMethod("didAcquirePointerLock", | |
366 &TestRunnerBindings::DidAcquirePointerLock) | |
367 .SetMethod("didLosePointerLock", &TestRunnerBindings::DidLosePointerLock) | |
368 .SetMethod("didNotAcquirePointerLock", | |
369 &TestRunnerBindings::DidNotAcquirePointerLock) | |
370 .SetMethod("disableAutoResizeMode", | |
371 &TestRunnerBindings::DisableAutoResizeMode) | |
372 .SetMethod("disableMockScreenOrientation", | |
373 &TestRunnerBindings::DisableMockScreenOrientation) | |
374 .SetMethod("setDisallowedSubresourcePathSuffixes", | |
375 &TestRunnerBindings::SetDisallowedSubresourcePathSuffixes) | |
376 .SetMethod("dispatchBeforeInstallPromptEvent", | |
377 &TestRunnerBindings::DispatchBeforeInstallPromptEvent) | |
378 .SetMethod("dumpAsMarkup", &TestRunnerBindings::DumpAsMarkup) | |
379 .SetMethod("dumpAsText", &TestRunnerBindings::DumpAsText) | |
380 .SetMethod("dumpAsTextWithPixelResults", | |
381 &TestRunnerBindings::DumpAsTextWithPixelResults) | |
382 .SetMethod("dumpBackForwardList", | |
383 &TestRunnerBindings::DumpBackForwardList) | |
384 .SetMethod("dumpChildFrameScrollPositions", | |
385 &TestRunnerBindings::DumpChildFrameScrollPositions) | |
386 .SetMethod("dumpChildFramesAsMarkup", | |
387 &TestRunnerBindings::DumpChildFramesAsMarkup) | |
388 .SetMethod("dumpChildFramesAsText", | |
389 &TestRunnerBindings::DumpChildFramesAsText) | |
390 .SetMethod("dumpCreateView", &TestRunnerBindings::DumpCreateView) | |
391 .SetMethod("dumpDatabaseCallbacks", &TestRunnerBindings::NotImplemented) | |
392 .SetMethod("dumpDragImage", &TestRunnerBindings::DumpDragImage) | |
393 .SetMethod("dumpEditingCallbacks", | |
394 &TestRunnerBindings::DumpEditingCallbacks) | |
395 .SetMethod("dumpFrameLoadCallbacks", | |
396 &TestRunnerBindings::DumpFrameLoadCallbacks) | |
397 .SetMethod("dumpIconChanges", &TestRunnerBindings::DumpIconChanges) | |
398 .SetMethod("dumpNavigationPolicy", | |
399 &TestRunnerBindings::DumpNavigationPolicy) | |
400 .SetMethod("dumpPageImportanceSignals", | |
401 &TestRunnerBindings::DumpPageImportanceSignals) | |
402 .SetMethod("dumpPermissionClientCallbacks", | |
403 &TestRunnerBindings::DumpPermissionClientCallbacks) | |
404 .SetMethod("dumpPingLoaderCallbacks", | |
405 &TestRunnerBindings::DumpPingLoaderCallbacks) | |
406 .SetMethod("dumpResourceLoadCallbacks", | |
407 &TestRunnerBindings::DumpResourceLoadCallbacks) | |
408 .SetMethod("dumpResourceResponseMIMETypes", | |
409 &TestRunnerBindings::DumpResourceResponseMIMETypes) | |
410 .SetMethod("dumpSelectionRect", &TestRunnerBindings::DumpSelectionRect) | |
411 .SetMethod("dumpSpellCheckCallbacks", | |
412 &TestRunnerBindings::DumpSpellCheckCallbacks) | |
413 | |
414 // Used at fast/dom/assign-to-window-status.html | |
415 .SetMethod("dumpStatusCallbacks", | |
416 &TestRunnerBindings::DumpWindowStatusChanges) | |
417 .SetMethod("dumpTitleChanges", &TestRunnerBindings::DumpTitleChanges) | |
418 .SetMethod("dumpUserGestureInFrameLoadCallbacks", | |
419 &TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks) | |
420 .SetMethod("enableAutoResizeMode", | |
421 &TestRunnerBindings::EnableAutoResizeMode) | |
422 .SetMethod("enableUseZoomForDSF", | |
423 &TestRunnerBindings::EnableUseZoomForDSF) | |
424 .SetMethod("evaluateInWebInspector", | |
425 &TestRunnerBindings::EvaluateInWebInspector) | |
426 .SetMethod("evaluateInWebInspectorOverlay", | |
427 &TestRunnerBindings::EvaluateInWebInspectorOverlay) | |
428 .SetMethod("evaluateScriptInIsolatedWorld", | |
429 &TestRunnerBindings::EvaluateScriptInIsolatedWorld) | |
430 .SetMethod( | |
431 "evaluateScriptInIsolatedWorldAndReturnValue", | |
432 &TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue) | |
433 .SetMethod("execCommand", &TestRunnerBindings::ExecCommand) | |
434 .SetMethod("findString", &TestRunnerBindings::FindString) | |
435 .SetMethod("forceNextDrawingBufferCreationToFail", | |
436 &TestRunnerBindings::ForceNextDrawingBufferCreationToFail) | |
437 .SetMethod("forceNextWebGLContextCreationToFail", | |
438 &TestRunnerBindings::ForceNextWebGLContextCreationToFail) | |
439 .SetMethod("forceRedSelectionColors", | |
440 &TestRunnerBindings::ForceRedSelectionColors) | |
441 | |
442 // The Bluetooth functions are specified at | |
443 // https://webbluetoothcg.github.io/web-bluetooth/tests/. | |
444 .SetMethod("getBluetoothManualChooserEvents", | |
445 &TestRunnerBindings::GetBluetoothManualChooserEvents) | |
446 .SetMethod("getManifestThen", &TestRunnerBindings::GetManifestThen) | |
447 .SetMethod("hasCustomPageSizeStyle", | |
448 &TestRunnerBindings::HasCustomPageSizeStyle) | |
449 .SetMethod("insertStyleSheet", &TestRunnerBindings::InsertStyleSheet) | |
450 .SetMethod("isChooserShown", &TestRunnerBindings::IsChooserShown) | |
451 .SetMethod("isCommandEnabled", &TestRunnerBindings::IsCommandEnabled) | |
452 .SetMethod("keepWebHistory", &TestRunnerBindings::NotImplemented) | |
453 .SetMethod("layoutAndPaintAsync", | |
454 &TestRunnerBindings::LayoutAndPaintAsync) | |
455 .SetMethod("layoutAndPaintAsyncThen", | |
456 &TestRunnerBindings::LayoutAndPaintAsyncThen) | |
457 .SetMethod("logToStderr", &TestRunnerBindings::LogToStderr) | |
458 .SetMethod("notifyDone", &TestRunnerBindings::NotifyDone) | |
459 .SetMethod("overridePreference", &TestRunnerBindings::OverridePreference) | |
460 .SetMethod("pathToLocalResource", | |
461 &TestRunnerBindings::PathToLocalResource) | |
462 .SetProperty("platformName", &TestRunnerBindings::PlatformName) | |
463 .SetMethod("queueBackNavigation", | |
464 &TestRunnerBindings::QueueBackNavigation) | |
465 .SetMethod("queueForwardNavigation", | |
466 &TestRunnerBindings::QueueForwardNavigation) | |
467 .SetMethod("queueLoad", &TestRunnerBindings::QueueLoad) | |
468 .SetMethod("queueLoadingScript", &TestRunnerBindings::QueueLoadingScript) | |
469 .SetMethod("queueNonLoadingScript", | |
470 &TestRunnerBindings::QueueNonLoadingScript) | |
471 .SetMethod("queueReload", &TestRunnerBindings::QueueReload) | |
472 .SetMethod("removeOriginAccessWhitelistEntry", | |
473 &TestRunnerBindings::RemoveOriginAccessWhitelistEntry) | |
474 .SetMethod("removeSpellCheckResolvedCallback", | |
475 &TestRunnerBindings::RemoveSpellCheckResolvedCallback) | |
476 .SetMethod("removeWebPageOverlay", | |
477 &TestRunnerBindings::RemoveWebPageOverlay) | |
478 .SetMethod("resetDeviceLight", &TestRunnerBindings::ResetDeviceLight) | |
479 .SetMethod("resetTestHelperControllers", | |
480 &TestRunnerBindings::ResetTestHelperControllers) | |
481 .SetMethod("resolveBeforeInstallPromptPromise", | |
482 &TestRunnerBindings::ResolveBeforeInstallPromptPromise) | |
483 .SetMethod("runIdleTasks", &TestRunnerBindings::RunIdleTasks) | |
484 .SetMethod("selectionAsMarkup", &TestRunnerBindings::SelectionAsMarkup) | |
485 | |
486 // The Bluetooth functions are specified at | |
487 // https://webbluetoothcg.github.io/web-bluetooth/tests/. | |
488 .SetMethod("sendBluetoothManualChooserEvent", | |
489 &TestRunnerBindings::SendBluetoothManualChooserEvent) | |
490 .SetMethod("setAcceptLanguages", &TestRunnerBindings::SetAcceptLanguages) | |
491 .SetMethod("setAllowFileAccessFromFileURLs", | |
492 &TestRunnerBindings::SetAllowFileAccessFromFileURLs) | |
493 .SetMethod("setAllowRunningOfInsecureContent", | |
494 &TestRunnerBindings::SetAllowRunningOfInsecureContent) | |
495 .SetMethod("setAutoplayAllowed", &TestRunnerBindings::SetAutoplayAllowed) | |
496 .SetMethod("setAllowUniversalAccessFromFileURLs", | |
497 &TestRunnerBindings::SetAllowUniversalAccessFromFileURLs) | |
498 .SetMethod("setBlockThirdPartyCookies", | |
499 &TestRunnerBindings::SetBlockThirdPartyCookies) | |
500 .SetMethod("setAudioData", &TestRunnerBindings::SetAudioData) | |
501 .SetMethod("setBackingScaleFactor", | |
502 &TestRunnerBindings::SetBackingScaleFactor) | |
503 // The Bluetooth functions are specified at | |
504 // https://webbluetoothcg.github.io/web-bluetooth/tests/. | |
505 .SetMethod("setBluetoothFakeAdapter", | |
506 &TestRunnerBindings::SetBluetoothFakeAdapter) | |
507 .SetMethod("setBluetoothManualChooser", | |
508 &TestRunnerBindings::SetBluetoothManualChooser) | |
509 .SetMethod("setCallCloseOnWebViews", &TestRunnerBindings::NotImplemented) | |
510 .SetMethod("setCanOpenWindows", &TestRunnerBindings::SetCanOpenWindows) | |
511 .SetMethod("setCloseRemainingWindowsWhenComplete", | |
512 &TestRunnerBindings::SetCloseRemainingWindowsWhenComplete) | |
513 .SetMethod("setColorProfile", &TestRunnerBindings::SetColorProfile) | |
514 .SetMethod("setCustomPolicyDelegate", | |
515 &TestRunnerBindings::SetCustomPolicyDelegate) | |
516 .SetMethod("setCustomTextOutput", | |
517 &TestRunnerBindings::SetCustomTextOutput) | |
518 .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota) | |
519 .SetMethod("setDomainRelaxationForbiddenForURLScheme", | |
520 &TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme) | |
521 .SetMethod("setDumpConsoleMessages", | |
522 &TestRunnerBindings::SetDumpConsoleMessages) | |
523 .SetMethod("setDumpJavaScriptDialogs", | |
524 &TestRunnerBindings::SetDumpJavaScriptDialogs) | |
525 .SetMethod("setEffectiveConnectionType", | |
526 &TestRunnerBindings::SetEffectiveConnectionType) | |
527 .SetMethod("setMockSpellCheckerEnabled", | |
528 &TestRunnerBindings::SetMockSpellCheckerEnabled) | |
529 .SetMethod("setIconDatabaseEnabled", &TestRunnerBindings::NotImplemented) | |
530 .SetMethod("setImagesAllowed", &TestRunnerBindings::SetImagesAllowed) | |
531 .SetMethod("setIsolatedWorldContentSecurityPolicy", | |
532 &TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy) | |
533 .SetMethod("setIsolatedWorldSecurityOrigin", | |
534 &TestRunnerBindings::SetIsolatedWorldSecurityOrigin) | |
535 .SetMethod("setJavaScriptCanAccessClipboard", | |
536 &TestRunnerBindings::SetJavaScriptCanAccessClipboard) | |
537 .SetMethod("setMIDIAccessorResult", | |
538 &TestRunnerBindings::SetMIDIAccessorResult) | |
539 .SetMethod("setMainFrameIsFirstResponder", | |
540 &TestRunnerBindings::NotImplemented) | |
541 .SetMethod("setMockDeviceLight", &TestRunnerBindings::SetMockDeviceLight) | |
542 .SetMethod("setMockDeviceMotion", | |
543 &TestRunnerBindings::SetMockDeviceMotion) | |
544 .SetMethod("setMockDeviceOrientation", | |
545 &TestRunnerBindings::SetMockDeviceOrientation) | |
546 .SetMethod("setMockScreenOrientation", | |
547 &TestRunnerBindings::SetMockScreenOrientation) | |
548 .SetMethod("setMockSpeechRecognitionError", | |
549 &TestRunnerBindings::SetMockSpeechRecognitionError) | |
550 .SetMethod("setPOSIXLocale", &TestRunnerBindings::SetPOSIXLocale) | |
551 .SetMethod("setPageVisibility", &TestRunnerBindings::SetPageVisibility) | |
552 .SetMethod("setPermission", &TestRunnerBindings::SetPermission) | |
553 .SetMethod("setPluginsAllowed", &TestRunnerBindings::SetPluginsAllowed) | |
554 .SetMethod("setPluginsEnabled", &TestRunnerBindings::SetPluginsEnabled) | |
555 .SetMethod("setPointerLockWillFailSynchronously", | |
556 &TestRunnerBindings::SetPointerLockWillFailSynchronously) | |
557 .SetMethod("setPointerLockWillRespondAsynchronously", | |
558 &TestRunnerBindings::SetPointerLockWillRespondAsynchronously) | |
559 .SetMethod("setPopupBlockingEnabled", | |
560 &TestRunnerBindings::SetPopupBlockingEnabled) | |
561 .SetMethod("setPrinting", &TestRunnerBindings::SetPrinting) | |
562 .SetMethod("setScriptsAllowed", &TestRunnerBindings::SetScriptsAllowed) | |
563 .SetMethod("setScrollbarPolicy", &TestRunnerBindings::NotImplemented) | |
564 .SetMethod( | |
565 "setShouldStayOnPageAfterHandlingBeforeUnload", | |
566 &TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload) | |
567 .SetMethod("setSpellCheckResolvedCallback", | |
568 &TestRunnerBindings::SetSpellCheckResolvedCallback) | |
569 .SetMethod("setStorageAllowed", &TestRunnerBindings::SetStorageAllowed) | |
570 .SetMethod("setTabKeyCyclesThroughElements", | |
571 &TestRunnerBindings::SetTabKeyCyclesThroughElements) | |
572 .SetMethod("setTextDirection", &TestRunnerBindings::SetTextDirection) | |
573 .SetMethod("setTextSubpixelPositioning", | |
574 &TestRunnerBindings::SetTextSubpixelPositioning) | |
575 .SetMethod("setUseDashboardCompatibilityMode", | |
576 &TestRunnerBindings::NotImplemented) | |
577 .SetMethod("setUseMockTheme", &TestRunnerBindings::SetUseMockTheme) | |
578 .SetMethod("setViewSourceForFrame", | |
579 &TestRunnerBindings::SetViewSourceForFrame) | |
580 .SetMethod("setWillSendRequestClearHeader", | |
581 &TestRunnerBindings::SetWillSendRequestClearHeader) | |
582 .SetMethod("setWindowIsKey", &TestRunnerBindings::SetWindowIsKey) | |
583 .SetMethod("setXSSAuditorEnabled", | |
584 &TestRunnerBindings::SetXSSAuditorEnabled) | |
585 .SetMethod("showWebInspector", &TestRunnerBindings::ShowWebInspector) | |
586 .SetMethod("simulateWebNotificationClick", | |
587 &TestRunnerBindings::SimulateWebNotificationClick) | |
588 .SetMethod("simulateWebNotificationClickWithReply", | |
589 &TestRunnerBindings::SimulateWebNotificationClickWithReply) | |
590 .SetMethod("simulateWebNotificationClose", | |
591 &TestRunnerBindings::SimulateWebNotificationClose) | |
592 .SetProperty("tooltipText", &TestRunnerBindings::TooltipText) | |
593 .SetMethod("useUnfortunateSynchronousResizeMode", | |
594 &TestRunnerBindings::UseUnfortunateSynchronousResizeMode) | |
595 .SetMethod("waitForPolicyDelegate", | |
596 &TestRunnerBindings::WaitForPolicyDelegate) | |
597 .SetMethod("waitUntilDone", &TestRunnerBindings::WaitUntilDone) | |
598 .SetMethod("waitUntilExternalURLLoad", | |
599 &TestRunnerBindings::WaitUntilExternalURLLoad) | |
600 | |
601 // webHistoryItemCount is used by tests in LayoutTests\http\tests\history | |
602 .SetProperty("webHistoryItemCount", | |
603 &TestRunnerBindings::WebHistoryItemCount) | |
604 .SetMethod("windowCount", &TestRunnerBindings::WindowCount); | |
605 } | |
606 | |
607 void TestRunnerBindings::LogToStderr(const std::string& output) { | |
608 LOG(ERROR) << output; | |
609 } | |
610 | |
611 void TestRunnerBindings::NotifyDone() { | |
612 if (runner_) | |
613 runner_->NotifyDone(); | |
614 } | |
615 | |
616 void TestRunnerBindings::WaitUntilDone() { | |
617 if (runner_) | |
618 runner_->WaitUntilDone(); | |
619 } | |
620 | |
621 void TestRunnerBindings::QueueBackNavigation(int how_far_back) { | |
622 if (runner_) | |
623 runner_->QueueBackNavigation(how_far_back); | |
624 } | |
625 | |
626 void TestRunnerBindings::QueueForwardNavigation(int how_far_forward) { | |
627 if (runner_) | |
628 runner_->QueueForwardNavigation(how_far_forward); | |
629 } | |
630 | |
631 void TestRunnerBindings::QueueReload() { | |
632 if (runner_) | |
633 runner_->QueueReload(); | |
634 } | |
635 | |
636 void TestRunnerBindings::QueueLoadingScript(const std::string& script) { | |
637 if (runner_) | |
638 runner_->QueueLoadingScript(script); | |
639 } | |
640 | |
641 void TestRunnerBindings::QueueNonLoadingScript(const std::string& script) { | |
642 if (runner_) | |
643 runner_->QueueNonLoadingScript(script); | |
644 } | |
645 | |
646 void TestRunnerBindings::QueueLoad(gin::Arguments* args) { | |
647 if (runner_) { | |
648 std::string url; | |
649 std::string target; | |
650 args->GetNext(&url); | |
651 args->GetNext(&target); | |
652 runner_->QueueLoad(url, target); | |
653 } | |
654 } | |
655 | |
656 void TestRunnerBindings::SetCustomPolicyDelegate(gin::Arguments* args) { | |
657 if (runner_) | |
658 runner_->SetCustomPolicyDelegate(args); | |
659 } | |
660 | |
661 void TestRunnerBindings::WaitForPolicyDelegate() { | |
662 if (runner_) | |
663 runner_->WaitForPolicyDelegate(); | |
664 } | |
665 | |
666 int TestRunnerBindings::WindowCount() { | |
667 if (runner_) | |
668 return runner_->WindowCount(); | |
669 return 0; | |
670 } | |
671 | |
672 void TestRunnerBindings::SetCloseRemainingWindowsWhenComplete( | |
673 gin::Arguments* args) { | |
674 if (!runner_) | |
675 return; | |
676 | |
677 // In the original implementation, nothing happens if the argument is | |
678 // ommitted. | |
679 bool close_remaining_windows = false; | |
680 if (args->GetNext(&close_remaining_windows)) | |
681 runner_->SetCloseRemainingWindowsWhenComplete(close_remaining_windows); | |
682 } | |
683 | |
684 void TestRunnerBindings::ResetTestHelperControllers() { | |
685 if (runner_) | |
686 runner_->ResetTestHelperControllers(); | |
687 } | |
688 | |
689 void TestRunnerBindings::SetTabKeyCyclesThroughElements( | |
690 bool tab_key_cycles_through_elements) { | |
691 if (view_runner_) | |
692 view_runner_->SetTabKeyCyclesThroughElements( | |
693 tab_key_cycles_through_elements); | |
694 } | |
695 | |
696 void TestRunnerBindings::ExecCommand(gin::Arguments* args) { | |
697 if (view_runner_) | |
698 view_runner_->ExecCommand(args); | |
699 } | |
700 | |
701 bool TestRunnerBindings::IsCommandEnabled(const std::string& command) { | |
702 if (view_runner_) | |
703 return view_runner_->IsCommandEnabled(command); | |
704 return false; | |
705 } | |
706 | |
707 bool TestRunnerBindings::CallShouldCloseOnWebView() { | |
708 if (view_runner_) | |
709 return view_runner_->CallShouldCloseOnWebView(); | |
710 return false; | |
711 } | |
712 | |
713 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme( | |
714 bool forbidden, const std::string& scheme) { | |
715 if (view_runner_) | |
716 view_runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme); | |
717 } | |
718 | |
719 void TestRunnerBindings::SetDumpConsoleMessages(bool enabled) { | |
720 if (runner_) | |
721 runner_->SetDumpConsoleMessages(enabled); | |
722 } | |
723 | |
724 void TestRunnerBindings::SetDumpJavaScriptDialogs(bool enabled) { | |
725 if (runner_) | |
726 runner_->SetDumpJavaScriptDialogs(enabled); | |
727 } | |
728 | |
729 void TestRunnerBindings::SetEffectiveConnectionType( | |
730 const std::string& connection_type) { | |
731 blink::WebEffectiveConnectionType web_type = | |
732 blink::WebEffectiveConnectionType::TypeUnknown; | |
733 if (connection_type == "TypeUnknown") | |
734 web_type = blink::WebEffectiveConnectionType::TypeUnknown; | |
735 else if (connection_type == "TypeOffline") | |
736 web_type = blink::WebEffectiveConnectionType::TypeOffline; | |
737 else if (connection_type == "TypeSlow2G") | |
738 web_type = blink::WebEffectiveConnectionType::TypeSlow2G; | |
739 else if (connection_type == "Type2G") | |
740 web_type = blink::WebEffectiveConnectionType::Type2G; | |
741 else if (connection_type == "Type3G") | |
742 web_type = blink::WebEffectiveConnectionType::Type3G; | |
743 else if (connection_type == "Type4G") | |
744 web_type = blink::WebEffectiveConnectionType::Type4G; | |
745 else | |
746 NOTREACHED(); | |
747 | |
748 if (runner_) | |
749 runner_->SetEffectiveConnectionType(web_type); | |
750 } | |
751 | |
752 void TestRunnerBindings::SetMockSpellCheckerEnabled(bool enabled) { | |
753 if (runner_) | |
754 runner_->SetMockSpellCheckerEnabled(enabled); | |
755 } | |
756 | |
757 void TestRunnerBindings::SetSpellCheckResolvedCallback( | |
758 v8::Local<v8::Function> callback) { | |
759 if (runner_) | |
760 runner_->spellcheck_->SetSpellCheckResolvedCallback(callback); | |
761 } | |
762 | |
763 void TestRunnerBindings::RemoveSpellCheckResolvedCallback() { | |
764 if (runner_) | |
765 runner_->spellcheck_->RemoveSpellCheckResolvedCallback(); | |
766 } | |
767 | |
768 v8::Local<v8::Value> | |
769 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue( | |
770 int world_id, const std::string& script) { | |
771 if (!view_runner_ || world_id <= 0 || world_id >= (1 << 29)) | |
772 return v8::Local<v8::Value>(); | |
773 return view_runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id, | |
774 script); | |
775 } | |
776 | |
777 void TestRunnerBindings::EvaluateScriptInIsolatedWorld( | |
778 int world_id, const std::string& script) { | |
779 if (view_runner_ && world_id > 0 && world_id < (1 << 29)) | |
780 view_runner_->EvaluateScriptInIsolatedWorld(world_id, script); | |
781 } | |
782 | |
783 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin( | |
784 int world_id, v8::Local<v8::Value> origin) { | |
785 if (view_runner_) | |
786 view_runner_->SetIsolatedWorldSecurityOrigin(world_id, origin); | |
787 } | |
788 | |
789 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy( | |
790 int world_id, const std::string& policy) { | |
791 if (view_runner_) | |
792 view_runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy); | |
793 } | |
794 | |
795 void TestRunnerBindings::AddOriginAccessWhitelistEntry( | |
796 const std::string& source_origin, | |
797 const std::string& destination_protocol, | |
798 const std::string& destination_host, | |
799 bool allow_destination_subdomains) { | |
800 if (runner_) { | |
801 runner_->AddOriginAccessWhitelistEntry(source_origin, | |
802 destination_protocol, | |
803 destination_host, | |
804 allow_destination_subdomains); | |
805 } | |
806 } | |
807 | |
808 void TestRunnerBindings::RemoveOriginAccessWhitelistEntry( | |
809 const std::string& source_origin, | |
810 const std::string& destination_protocol, | |
811 const std::string& destination_host, | |
812 bool allow_destination_subdomains) { | |
813 if (runner_) { | |
814 runner_->RemoveOriginAccessWhitelistEntry(source_origin, | |
815 destination_protocol, | |
816 destination_host, | |
817 allow_destination_subdomains); | |
818 } | |
819 } | |
820 | |
821 bool TestRunnerBindings::HasCustomPageSizeStyle(int page_index) { | |
822 if (view_runner_) | |
823 return view_runner_->HasCustomPageSizeStyle(page_index); | |
824 return false; | |
825 } | |
826 | |
827 void TestRunnerBindings::ForceRedSelectionColors() { | |
828 if (view_runner_) | |
829 view_runner_->ForceRedSelectionColors(); | |
830 } | |
831 | |
832 void TestRunnerBindings::InsertStyleSheet(const std::string& source_code) { | |
833 if (runner_) | |
834 runner_->InsertStyleSheet(source_code); | |
835 } | |
836 | |
837 bool TestRunnerBindings::FindString( | |
838 const std::string& search_text, | |
839 const std::vector<std::string>& options_array) { | |
840 if (view_runner_) | |
841 return view_runner_->FindString(search_text, options_array); | |
842 return false; | |
843 } | |
844 | |
845 std::string TestRunnerBindings::SelectionAsMarkup() { | |
846 if (view_runner_) | |
847 return view_runner_->SelectionAsMarkup(); | |
848 return std::string(); | |
849 } | |
850 | |
851 void TestRunnerBindings::SetTextSubpixelPositioning(bool value) { | |
852 if (runner_) | |
853 runner_->SetTextSubpixelPositioning(value); | |
854 } | |
855 | |
856 void TestRunnerBindings::SetPageVisibility(const std::string& new_visibility) { | |
857 if (view_runner_) | |
858 view_runner_->SetPageVisibility(new_visibility); | |
859 } | |
860 | |
861 void TestRunnerBindings::SetTextDirection(const std::string& direction_name) { | |
862 if (view_runner_) | |
863 view_runner_->SetTextDirection(direction_name); | |
864 } | |
865 | |
866 void TestRunnerBindings::UseUnfortunateSynchronousResizeMode() { | |
867 if (runner_) | |
868 runner_->UseUnfortunateSynchronousResizeMode(); | |
869 } | |
870 | |
871 bool TestRunnerBindings::EnableAutoResizeMode(int min_width, | |
872 int min_height, | |
873 int max_width, | |
874 int max_height) { | |
875 if (runner_) { | |
876 return runner_->EnableAutoResizeMode(min_width, min_height, | |
877 max_width, max_height); | |
878 } | |
879 return false; | |
880 } | |
881 | |
882 bool TestRunnerBindings::DisableAutoResizeMode(int new_width, int new_height) { | |
883 if (runner_) | |
884 return runner_->DisableAutoResizeMode(new_width, new_height); | |
885 return false; | |
886 } | |
887 | |
888 void TestRunnerBindings::SetMockDeviceLight(double value) { | |
889 if (!runner_) | |
890 return; | |
891 runner_->SetMockDeviceLight(value); | |
892 } | |
893 | |
894 void TestRunnerBindings::ResetDeviceLight() { | |
895 if (runner_) | |
896 runner_->ResetDeviceLight(); | |
897 } | |
898 | |
899 void TestRunnerBindings::SetMockDeviceMotion(gin::Arguments* args) { | |
900 if (!runner_) | |
901 return; | |
902 | |
903 bool has_acceleration_x = false; | |
904 double acceleration_x = 0.0; | |
905 bool has_acceleration_y = false; | |
906 double acceleration_y = 0.0; | |
907 bool has_acceleration_z = false; | |
908 double acceleration_z = 0.0; | |
909 bool has_acceleration_including_gravity_x = false; | |
910 double acceleration_including_gravity_x = 0.0; | |
911 bool has_acceleration_including_gravity_y = false; | |
912 double acceleration_including_gravity_y = 0.0; | |
913 bool has_acceleration_including_gravity_z = false; | |
914 double acceleration_including_gravity_z = 0.0; | |
915 bool has_rotation_rate_alpha = false; | |
916 double rotation_rate_alpha = 0.0; | |
917 bool has_rotation_rate_beta = false; | |
918 double rotation_rate_beta = 0.0; | |
919 bool has_rotation_rate_gamma = false; | |
920 double rotation_rate_gamma = 0.0; | |
921 double interval = false; | |
922 | |
923 args->GetNext(&has_acceleration_x); | |
924 args->GetNext(&acceleration_x); | |
925 args->GetNext(&has_acceleration_y); | |
926 args->GetNext(&acceleration_y); | |
927 args->GetNext(&has_acceleration_z); | |
928 args->GetNext(&acceleration_z); | |
929 args->GetNext(&has_acceleration_including_gravity_x); | |
930 args->GetNext(&acceleration_including_gravity_x); | |
931 args->GetNext(&has_acceleration_including_gravity_y); | |
932 args->GetNext(&acceleration_including_gravity_y); | |
933 args->GetNext(&has_acceleration_including_gravity_z); | |
934 args->GetNext(&acceleration_including_gravity_z); | |
935 args->GetNext(&has_rotation_rate_alpha); | |
936 args->GetNext(&rotation_rate_alpha); | |
937 args->GetNext(&has_rotation_rate_beta); | |
938 args->GetNext(&rotation_rate_beta); | |
939 args->GetNext(&has_rotation_rate_gamma); | |
940 args->GetNext(&rotation_rate_gamma); | |
941 args->GetNext(&interval); | |
942 | |
943 runner_->SetMockDeviceMotion(has_acceleration_x, acceleration_x, | |
944 has_acceleration_y, acceleration_y, | |
945 has_acceleration_z, acceleration_z, | |
946 has_acceleration_including_gravity_x, | |
947 acceleration_including_gravity_x, | |
948 has_acceleration_including_gravity_y, | |
949 acceleration_including_gravity_y, | |
950 has_acceleration_including_gravity_z, | |
951 acceleration_including_gravity_z, | |
952 has_rotation_rate_alpha, | |
953 rotation_rate_alpha, | |
954 has_rotation_rate_beta, | |
955 rotation_rate_beta, | |
956 has_rotation_rate_gamma, | |
957 rotation_rate_gamma, | |
958 interval); | |
959 } | |
960 | |
961 void TestRunnerBindings::SetMockDeviceOrientation(gin::Arguments* args) { | |
962 if (!runner_) | |
963 return; | |
964 | |
965 bool has_alpha = false; | |
966 double alpha = 0.0; | |
967 bool has_beta = false; | |
968 double beta = 0.0; | |
969 bool has_gamma = false; | |
970 double gamma = 0.0; | |
971 bool absolute = false; | |
972 | |
973 args->GetNext(&has_alpha); | |
974 args->GetNext(&alpha); | |
975 args->GetNext(&has_beta); | |
976 args->GetNext(&beta); | |
977 args->GetNext(&has_gamma); | |
978 args->GetNext(&gamma); | |
979 args->GetNext(&absolute); | |
980 | |
981 runner_->SetMockDeviceOrientation(has_alpha, alpha, | |
982 has_beta, beta, | |
983 has_gamma, gamma, | |
984 absolute); | |
985 } | |
986 | |
987 void TestRunnerBindings::SetMockScreenOrientation( | |
988 const std::string& orientation) { | |
989 if (!runner_) | |
990 return; | |
991 | |
992 runner_->SetMockScreenOrientation(orientation); | |
993 } | |
994 | |
995 void TestRunnerBindings::DisableMockScreenOrientation() { | |
996 if (runner_) | |
997 runner_->DisableMockScreenOrientation(); | |
998 } | |
999 | |
1000 void TestRunnerBindings::SetDisallowedSubresourcePathSuffixes( | |
1001 const std::vector<std::string>& suffixes) { | |
1002 if (runner_) | |
1003 runner_->SetDisallowedSubresourcePathSuffixes(suffixes); | |
1004 } | |
1005 | |
1006 void TestRunnerBindings::DidAcquirePointerLock() { | |
1007 if (view_runner_) | |
1008 view_runner_->DidAcquirePointerLock(); | |
1009 } | |
1010 | |
1011 void TestRunnerBindings::DidNotAcquirePointerLock() { | |
1012 if (view_runner_) | |
1013 view_runner_->DidNotAcquirePointerLock(); | |
1014 } | |
1015 | |
1016 void TestRunnerBindings::DidLosePointerLock() { | |
1017 if (view_runner_) | |
1018 view_runner_->DidLosePointerLock(); | |
1019 } | |
1020 | |
1021 void TestRunnerBindings::SetPointerLockWillFailSynchronously() { | |
1022 if (view_runner_) | |
1023 view_runner_->SetPointerLockWillFailSynchronously(); | |
1024 } | |
1025 | |
1026 void TestRunnerBindings::SetPointerLockWillRespondAsynchronously() { | |
1027 if (view_runner_) | |
1028 view_runner_->SetPointerLockWillRespondAsynchronously(); | |
1029 } | |
1030 | |
1031 void TestRunnerBindings::SetPopupBlockingEnabled(bool block_popups) { | |
1032 if (runner_) | |
1033 runner_->SetPopupBlockingEnabled(block_popups); | |
1034 } | |
1035 | |
1036 void TestRunnerBindings::SetJavaScriptCanAccessClipboard(bool can_access) { | |
1037 if (runner_) | |
1038 runner_->SetJavaScriptCanAccessClipboard(can_access); | |
1039 } | |
1040 | |
1041 void TestRunnerBindings::SetXSSAuditorEnabled(bool enabled) { | |
1042 if (runner_) | |
1043 runner_->SetXSSAuditorEnabled(enabled); | |
1044 } | |
1045 | |
1046 void TestRunnerBindings::SetAllowUniversalAccessFromFileURLs(bool allow) { | |
1047 if (runner_) | |
1048 runner_->SetAllowUniversalAccessFromFileURLs(allow); | |
1049 } | |
1050 | |
1051 void TestRunnerBindings::SetAllowFileAccessFromFileURLs(bool allow) { | |
1052 if (runner_) | |
1053 runner_->SetAllowFileAccessFromFileURLs(allow); | |
1054 } | |
1055 | |
1056 void TestRunnerBindings::OverridePreference(const std::string& key, | |
1057 v8::Local<v8::Value> value) { | |
1058 if (runner_) | |
1059 runner_->OverridePreference(key, value); | |
1060 } | |
1061 | |
1062 void TestRunnerBindings::SetAcceptLanguages( | |
1063 const std::string& accept_languages) { | |
1064 if (!runner_) | |
1065 return; | |
1066 | |
1067 runner_->SetAcceptLanguages(accept_languages); | |
1068 } | |
1069 | |
1070 void TestRunnerBindings::SetPluginsEnabled(bool enabled) { | |
1071 if (runner_) | |
1072 runner_->SetPluginsEnabled(enabled); | |
1073 } | |
1074 | |
1075 void TestRunnerBindings::DumpEditingCallbacks() { | |
1076 if (runner_) | |
1077 runner_->DumpEditingCallbacks(); | |
1078 } | |
1079 | |
1080 void TestRunnerBindings::DumpAsMarkup() { | |
1081 if (runner_) | |
1082 runner_->DumpAsMarkup(); | |
1083 } | |
1084 | |
1085 void TestRunnerBindings::DumpAsText() { | |
1086 if (runner_) | |
1087 runner_->DumpAsText(); | |
1088 } | |
1089 | |
1090 void TestRunnerBindings::DumpAsTextWithPixelResults() { | |
1091 if (runner_) | |
1092 runner_->DumpAsTextWithPixelResults(); | |
1093 } | |
1094 | |
1095 void TestRunnerBindings::DumpChildFrameScrollPositions() { | |
1096 if (runner_) | |
1097 runner_->DumpChildFrameScrollPositions(); | |
1098 } | |
1099 | |
1100 void TestRunnerBindings::DumpChildFramesAsText() { | |
1101 if (runner_) | |
1102 runner_->DumpChildFramesAsText(); | |
1103 } | |
1104 | |
1105 void TestRunnerBindings::DumpChildFramesAsMarkup() { | |
1106 if (runner_) | |
1107 runner_->DumpChildFramesAsMarkup(); | |
1108 } | |
1109 | |
1110 void TestRunnerBindings::DumpIconChanges() { | |
1111 if (runner_) | |
1112 runner_->DumpIconChanges(); | |
1113 } | |
1114 | |
1115 void TestRunnerBindings::SetAudioData(const gin::ArrayBufferView& view) { | |
1116 if (runner_) | |
1117 runner_->SetAudioData(view); | |
1118 } | |
1119 | |
1120 void TestRunnerBindings::DumpFrameLoadCallbacks() { | |
1121 if (runner_) | |
1122 runner_->DumpFrameLoadCallbacks(); | |
1123 } | |
1124 | |
1125 void TestRunnerBindings::DumpPingLoaderCallbacks() { | |
1126 if (runner_) | |
1127 runner_->DumpPingLoaderCallbacks(); | |
1128 } | |
1129 | |
1130 void TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks() { | |
1131 if (runner_) | |
1132 runner_->DumpUserGestureInFrameLoadCallbacks(); | |
1133 } | |
1134 | |
1135 void TestRunnerBindings::DumpTitleChanges() { | |
1136 if (runner_) | |
1137 runner_->DumpTitleChanges(); | |
1138 } | |
1139 | |
1140 void TestRunnerBindings::DumpCreateView() { | |
1141 if (runner_) | |
1142 runner_->DumpCreateView(); | |
1143 } | |
1144 | |
1145 void TestRunnerBindings::SetCanOpenWindows() { | |
1146 if (runner_) | |
1147 runner_->SetCanOpenWindows(); | |
1148 } | |
1149 | |
1150 void TestRunnerBindings::DumpResourceLoadCallbacks() { | |
1151 if (runner_) | |
1152 runner_->DumpResourceLoadCallbacks(); | |
1153 } | |
1154 | |
1155 void TestRunnerBindings::DumpResourceResponseMIMETypes() { | |
1156 if (runner_) | |
1157 runner_->DumpResourceResponseMIMETypes(); | |
1158 } | |
1159 | |
1160 void TestRunnerBindings::SetImagesAllowed(bool allowed) { | |
1161 if (runner_) | |
1162 runner_->SetImagesAllowed(allowed); | |
1163 } | |
1164 | |
1165 void TestRunnerBindings::SetScriptsAllowed(bool allowed) { | |
1166 if (runner_) | |
1167 runner_->SetScriptsAllowed(allowed); | |
1168 } | |
1169 | |
1170 void TestRunnerBindings::SetStorageAllowed(bool allowed) { | |
1171 if (runner_) | |
1172 runner_->SetStorageAllowed(allowed); | |
1173 } | |
1174 | |
1175 void TestRunnerBindings::SetPluginsAllowed(bool allowed) { | |
1176 if (runner_) | |
1177 runner_->SetPluginsAllowed(allowed); | |
1178 } | |
1179 | |
1180 void TestRunnerBindings::SetAllowRunningOfInsecureContent(bool allowed) { | |
1181 if (runner_) | |
1182 runner_->SetAllowRunningOfInsecureContent(allowed); | |
1183 } | |
1184 | |
1185 void TestRunnerBindings::SetAutoplayAllowed(bool allowed) { | |
1186 if (runner_) | |
1187 runner_->SetAutoplayAllowed(allowed); | |
1188 } | |
1189 | |
1190 void TestRunnerBindings::DumpPermissionClientCallbacks() { | |
1191 if (runner_) | |
1192 runner_->DumpPermissionClientCallbacks(); | |
1193 } | |
1194 | |
1195 void TestRunnerBindings::DumpWindowStatusChanges() { | |
1196 if (runner_) | |
1197 runner_->DumpWindowStatusChanges(); | |
1198 } | |
1199 | |
1200 void TestRunnerBindings::DumpSpellCheckCallbacks() { | |
1201 if (runner_) | |
1202 runner_->DumpSpellCheckCallbacks(); | |
1203 } | |
1204 | |
1205 void TestRunnerBindings::DumpBackForwardList() { | |
1206 if (runner_) | |
1207 runner_->DumpBackForwardList(); | |
1208 } | |
1209 | |
1210 void TestRunnerBindings::DumpSelectionRect() { | |
1211 if (runner_) | |
1212 runner_->DumpSelectionRect(); | |
1213 } | |
1214 | |
1215 void TestRunnerBindings::SetPrinting() { | |
1216 if (runner_) | |
1217 runner_->SetPrinting(); | |
1218 } | |
1219 | |
1220 void TestRunnerBindings::ClearPrinting() { | |
1221 if (runner_) | |
1222 runner_->ClearPrinting(); | |
1223 } | |
1224 | |
1225 void TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload( | |
1226 bool value) { | |
1227 if (runner_) | |
1228 runner_->SetShouldStayOnPageAfterHandlingBeforeUnload(value); | |
1229 } | |
1230 | |
1231 void TestRunnerBindings::SetWillSendRequestClearHeader( | |
1232 const std::string& header) { | |
1233 if (runner_) | |
1234 runner_->SetWillSendRequestClearHeader(header); | |
1235 } | |
1236 | |
1237 void TestRunnerBindings::SetUseMockTheme(bool use) { | |
1238 if (runner_) | |
1239 runner_->SetUseMockTheme(use); | |
1240 } | |
1241 | |
1242 void TestRunnerBindings::WaitUntilExternalURLLoad() { | |
1243 if (runner_) | |
1244 runner_->WaitUntilExternalURLLoad(); | |
1245 } | |
1246 | |
1247 void TestRunnerBindings::DumpDragImage() { | |
1248 if (runner_) | |
1249 runner_->DumpDragImage(); | |
1250 } | |
1251 | |
1252 void TestRunnerBindings::DumpNavigationPolicy() { | |
1253 if (runner_) | |
1254 runner_->DumpNavigationPolicy(); | |
1255 } | |
1256 | |
1257 void TestRunnerBindings::DumpPageImportanceSignals() { | |
1258 if (view_runner_) | |
1259 view_runner_->DumpPageImportanceSignals(); | |
1260 } | |
1261 | |
1262 void TestRunnerBindings::ShowWebInspector(gin::Arguments* args) { | |
1263 if (runner_) { | |
1264 std::string settings; | |
1265 args->GetNext(&settings); | |
1266 std::string frontend_url; | |
1267 args->GetNext(&frontend_url); | |
1268 runner_->ShowWebInspector(settings, frontend_url); | |
1269 } | |
1270 } | |
1271 | |
1272 void TestRunnerBindings::CloseWebInspector() { | |
1273 if (runner_) | |
1274 runner_->CloseWebInspector(); | |
1275 } | |
1276 | |
1277 bool TestRunnerBindings::IsChooserShown() { | |
1278 if (runner_) | |
1279 return runner_->IsChooserShown(); | |
1280 return false; | |
1281 } | |
1282 | |
1283 void TestRunnerBindings::EvaluateInWebInspector(int call_id, | |
1284 const std::string& script) { | |
1285 if (runner_) | |
1286 runner_->EvaluateInWebInspector(call_id, script); | |
1287 } | |
1288 | |
1289 std::string TestRunnerBindings::EvaluateInWebInspectorOverlay( | |
1290 const std::string& script) { | |
1291 if (runner_) | |
1292 return runner_->EvaluateInWebInspectorOverlay(script); | |
1293 | |
1294 return std::string(); | |
1295 } | |
1296 | |
1297 void TestRunnerBindings::ClearAllDatabases() { | |
1298 if (runner_) | |
1299 runner_->ClearAllDatabases(); | |
1300 } | |
1301 | |
1302 void TestRunnerBindings::SetDatabaseQuota(int quota) { | |
1303 if (runner_) | |
1304 runner_->SetDatabaseQuota(quota); | |
1305 } | |
1306 | |
1307 void TestRunnerBindings::SetBlockThirdPartyCookies(bool block) { | |
1308 if (runner_) | |
1309 runner_->SetBlockThirdPartyCookies(block); | |
1310 } | |
1311 | |
1312 void TestRunnerBindings::SetWindowIsKey(bool value) { | |
1313 if (view_runner_) | |
1314 view_runner_->SetWindowIsKey(value); | |
1315 } | |
1316 | |
1317 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) { | |
1318 if (runner_) | |
1319 return runner_->PathToLocalResource(path); | |
1320 return std::string(); | |
1321 } | |
1322 | |
1323 void TestRunnerBindings::SetBackingScaleFactor( | |
1324 double value, v8::Local<v8::Function> callback) { | |
1325 if (view_runner_) | |
1326 view_runner_->SetBackingScaleFactor(value, callback); | |
1327 } | |
1328 | |
1329 void TestRunnerBindings::EnableUseZoomForDSF( | |
1330 v8::Local<v8::Function> callback) { | |
1331 if (view_runner_) | |
1332 view_runner_->EnableUseZoomForDSF(callback); | |
1333 } | |
1334 | |
1335 void TestRunnerBindings::SetColorProfile( | |
1336 const std::string& name, v8::Local<v8::Function> callback) { | |
1337 if (view_runner_) | |
1338 view_runner_->SetColorProfile(name, callback); | |
1339 } | |
1340 | |
1341 void TestRunnerBindings::SetBluetoothFakeAdapter( | |
1342 const std::string& adapter_name, | |
1343 v8::Local<v8::Function> callback) { | |
1344 if (view_runner_) | |
1345 view_runner_->SetBluetoothFakeAdapter(adapter_name, callback); | |
1346 } | |
1347 | |
1348 void TestRunnerBindings::SetBluetoothManualChooser(bool enable) { | |
1349 if (view_runner_) | |
1350 view_runner_->SetBluetoothManualChooser(enable); | |
1351 } | |
1352 | |
1353 void TestRunnerBindings::GetBluetoothManualChooserEvents( | |
1354 v8::Local<v8::Function> callback) { | |
1355 if (view_runner_) | |
1356 return view_runner_->GetBluetoothManualChooserEvents(callback); | |
1357 } | |
1358 | |
1359 void TestRunnerBindings::SendBluetoothManualChooserEvent( | |
1360 const std::string& event, | |
1361 const std::string& argument) { | |
1362 if (view_runner_) | |
1363 view_runner_->SendBluetoothManualChooserEvent(event, argument); | |
1364 } | |
1365 | |
1366 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) { | |
1367 if (runner_) | |
1368 runner_->SetPOSIXLocale(locale); | |
1369 } | |
1370 | |
1371 void TestRunnerBindings::SetMIDIAccessorResult(bool result) { | |
1372 if (runner_) { | |
1373 runner_->SetMIDIAccessorResult( | |
1374 result ? midi::mojom::Result::OK | |
1375 : midi::mojom::Result::INITIALIZATION_ERROR); | |
1376 } | |
1377 } | |
1378 | |
1379 void TestRunnerBindings::SimulateWebNotificationClick(const std::string& title, | |
1380 int action_index) { | |
1381 if (!runner_) | |
1382 return; | |
1383 runner_->SimulateWebNotificationClick(title, action_index, | |
1384 base::NullableString16()); | |
1385 } | |
1386 | |
1387 void TestRunnerBindings::SimulateWebNotificationClickWithReply( | |
1388 const std::string& title, | |
1389 int action_index, | |
1390 const std::string& reply) { | |
1391 if (!runner_) | |
1392 return; | |
1393 runner_->SimulateWebNotificationClick( | |
1394 title, action_index, | |
1395 base::NullableString16(base::UTF8ToUTF16(reply), false /* is_null */)); | |
1396 } | |
1397 | |
1398 void TestRunnerBindings::SimulateWebNotificationClose(const std::string& title, | |
1399 bool by_user) { | |
1400 if (!runner_) | |
1401 return; | |
1402 runner_->SimulateWebNotificationClose(title, by_user); | |
1403 } | |
1404 | |
1405 void TestRunnerBindings::AddMockSpeechRecognitionResult( | |
1406 const std::string& transcript, double confidence) { | |
1407 if (runner_) | |
1408 runner_->AddMockSpeechRecognitionResult(transcript, confidence); | |
1409 } | |
1410 | |
1411 void TestRunnerBindings::SetMockSpeechRecognitionError( | |
1412 const std::string& error, const std::string& message) { | |
1413 if (runner_) | |
1414 runner_->SetMockSpeechRecognitionError(error, message); | |
1415 } | |
1416 | |
1417 void TestRunnerBindings::SetMockCredentialManagerResponse( | |
1418 const std::string& id, | |
1419 const std::string& name, | |
1420 const std::string& avatar, | |
1421 const std::string& password) { | |
1422 if (runner_) | |
1423 runner_->SetMockCredentialManagerResponse(id, name, avatar, password); | |
1424 } | |
1425 | |
1426 void TestRunnerBindings::ClearMockCredentialManagerResponse() { | |
1427 if (runner_) | |
1428 runner_->ClearMockCredentialManagerResponse(); | |
1429 } | |
1430 | |
1431 void TestRunnerBindings::SetMockCredentialManagerError( | |
1432 const std::string& error) { | |
1433 if (runner_) | |
1434 runner_->SetMockCredentialManagerError(error); | |
1435 } | |
1436 | |
1437 void TestRunnerBindings::AddWebPageOverlay() { | |
1438 if (view_runner_) | |
1439 view_runner_->AddWebPageOverlay(); | |
1440 } | |
1441 | |
1442 void TestRunnerBindings::RemoveWebPageOverlay() { | |
1443 if (view_runner_) | |
1444 view_runner_->RemoveWebPageOverlay(); | |
1445 } | |
1446 | |
1447 void TestRunnerBindings::LayoutAndPaintAsync() { | |
1448 if (view_runner_) | |
1449 view_runner_->LayoutAndPaintAsync(); | |
1450 } | |
1451 | |
1452 void TestRunnerBindings::LayoutAndPaintAsyncThen( | |
1453 v8::Local<v8::Function> callback) { | |
1454 if (view_runner_) | |
1455 view_runner_->LayoutAndPaintAsyncThen(callback); | |
1456 } | |
1457 | |
1458 void TestRunnerBindings::GetManifestThen(v8::Local<v8::Function> callback) { | |
1459 if (view_runner_) | |
1460 view_runner_->GetManifestThen(callback); | |
1461 } | |
1462 | |
1463 void TestRunnerBindings::CapturePixelsAsyncThen( | |
1464 v8::Local<v8::Function> callback) { | |
1465 if (view_runner_) | |
1466 view_runner_->CapturePixelsAsyncThen(callback); | |
1467 } | |
1468 | |
1469 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen( | |
1470 int x, int y, v8::Local<v8::Function> callback) { | |
1471 if (view_runner_) | |
1472 view_runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback); | |
1473 } | |
1474 | |
1475 void TestRunnerBindings::SetCustomTextOutput(const std::string& output) { | |
1476 if (runner_) | |
1477 runner_->setCustomTextOutput(output); | |
1478 } | |
1479 | |
1480 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name, | |
1481 bool enabled) { | |
1482 if (view_runner_) | |
1483 view_runner_->SetViewSourceForFrame(name, enabled); | |
1484 } | |
1485 | |
1486 void TestRunnerBindings::SetPermission(const std::string& name, | |
1487 const std::string& value, | |
1488 const std::string& origin, | |
1489 const std::string& embedding_origin) { | |
1490 if (!runner_) | |
1491 return; | |
1492 | |
1493 return runner_->SetPermission( | |
1494 name, value, GURL(origin), GURL(embedding_origin)); | |
1495 } | |
1496 | |
1497 void TestRunnerBindings::DispatchBeforeInstallPromptEvent( | |
1498 const std::vector<std::string>& event_platforms, | |
1499 v8::Local<v8::Function> callback) { | |
1500 if (!view_runner_) | |
1501 return; | |
1502 | |
1503 return view_runner_->DispatchBeforeInstallPromptEvent(event_platforms, | |
1504 callback); | |
1505 } | |
1506 | |
1507 void TestRunnerBindings::ResolveBeforeInstallPromptPromise( | |
1508 const std::string& platform) { | |
1509 if (!runner_) | |
1510 return; | |
1511 | |
1512 runner_->ResolveBeforeInstallPromptPromise(platform); | |
1513 } | |
1514 | |
1515 void TestRunnerBindings::RunIdleTasks(v8::Local<v8::Function> callback) { | |
1516 if (!view_runner_) | |
1517 return; | |
1518 view_runner_->RunIdleTasks(callback); | |
1519 } | |
1520 | |
1521 std::string TestRunnerBindings::PlatformName() { | |
1522 if (runner_) | |
1523 return runner_->platform_name_; | |
1524 return std::string(); | |
1525 } | |
1526 | |
1527 std::string TestRunnerBindings::TooltipText() { | |
1528 if (runner_) | |
1529 return runner_->tooltip_text_; | |
1530 return std::string(); | |
1531 } | |
1532 | |
1533 int TestRunnerBindings::WebHistoryItemCount() { | |
1534 if (runner_) | |
1535 return runner_->web_history_item_count_; | |
1536 return false; | |
1537 } | |
1538 | |
1539 void TestRunnerBindings::ForceNextWebGLContextCreationToFail() { | |
1540 if (view_runner_) | |
1541 view_runner_->ForceNextWebGLContextCreationToFail(); | |
1542 } | |
1543 | |
1544 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() { | |
1545 if (view_runner_) | |
1546 view_runner_->ForceNextDrawingBufferCreationToFail(); | |
1547 } | |
1548 | |
1549 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) { | |
1550 } | |
1551 | |
1552 TestRunner::WorkQueue::WorkQueue(TestRunner* controller) | |
1553 : frozen_(false), controller_(controller), weak_factory_(this) {} | |
1554 | |
1555 TestRunner::WorkQueue::~WorkQueue() { | |
1556 Reset(); | |
1557 } | |
1558 | |
1559 void TestRunner::WorkQueue::ProcessWorkSoon() { | |
1560 if (controller_->topLoadingFrame()) | |
1561 return; | |
1562 | |
1563 if (!queue_.empty()) { | |
1564 // We delay processing queued work to avoid recursion problems. | |
1565 controller_->delegate_->PostTask(base::Bind( | |
1566 &TestRunner::WorkQueue::ProcessWork, weak_factory_.GetWeakPtr())); | |
1567 } else if (!controller_->layout_test_runtime_flags_.wait_until_done()) { | |
1568 controller_->delegate_->TestFinished(); | |
1569 } | |
1570 } | |
1571 | |
1572 void TestRunner::WorkQueue::Reset() { | |
1573 frozen_ = false; | |
1574 while (!queue_.empty()) { | |
1575 delete queue_.front(); | |
1576 queue_.pop_front(); | |
1577 } | |
1578 } | |
1579 | |
1580 void TestRunner::WorkQueue::AddWork(WorkItem* work) { | |
1581 if (frozen_) { | |
1582 delete work; | |
1583 return; | |
1584 } | |
1585 queue_.push_back(work); | |
1586 } | |
1587 | |
1588 void TestRunner::WorkQueue::ProcessWork() { | |
1589 // Quit doing work once a load is in progress. | |
1590 if (controller_->main_view_) { | |
1591 while (!queue_.empty()) { | |
1592 bool startedLoad = | |
1593 queue_.front()->Run(controller_->delegate_, controller_->main_view_); | |
1594 delete queue_.front(); | |
1595 queue_.pop_front(); | |
1596 if (startedLoad) | |
1597 return; | |
1598 } | |
1599 } | |
1600 | |
1601 if (!controller_->layout_test_runtime_flags_.wait_until_done() && | |
1602 !controller_->topLoadingFrame()) | |
1603 controller_->delegate_->TestFinished(); | |
1604 } | |
1605 | |
1606 TestRunner::TestRunner(TestInterfaces* interfaces) | |
1607 : test_is_running_(false), | |
1608 close_remaining_windows_(false), | |
1609 work_queue_(this), | |
1610 web_history_item_count_(0), | |
1611 test_interfaces_(interfaces), | |
1612 delegate_(nullptr), | |
1613 main_view_(nullptr), | |
1614 mock_content_settings_client_( | |
1615 new MockContentSettingsClient(&layout_test_runtime_flags_)), | |
1616 will_navigate_(false), | |
1617 credential_manager_client_(new MockCredentialManagerClient), | |
1618 mock_screen_orientation_client_(new MockScreenOrientationClient), | |
1619 spellcheck_(new SpellCheckClient(this)), | |
1620 chooser_count_(0), | |
1621 previously_focused_view_(nullptr), | |
1622 is_web_platform_tests_mode_(false), | |
1623 effective_connection_type_( | |
1624 blink::WebEffectiveConnectionType::TypeUnknown), | |
1625 weak_factory_(this) {} | |
1626 | |
1627 TestRunner::~TestRunner() {} | |
1628 | |
1629 void TestRunner::Install( | |
1630 WebLocalFrame* frame, | |
1631 base::WeakPtr<TestRunnerForSpecificView> view_test_runner) { | |
1632 TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), view_test_runner, | |
1633 frame); | |
1634 } | |
1635 | |
1636 void TestRunner::SetDelegate(WebTestDelegate* delegate) { | |
1637 delegate_ = delegate; | |
1638 mock_content_settings_client_->SetDelegate(delegate); | |
1639 spellcheck_->SetDelegate(delegate); | |
1640 if (speech_recognizer_) | |
1641 speech_recognizer_->SetDelegate(delegate); | |
1642 } | |
1643 | |
1644 void TestRunner::SetMainView(WebView* web_view) { | |
1645 main_view_ = web_view; | |
1646 if (disable_v8_cache_) | |
1647 SetV8CacheDisabled(true); | |
1648 } | |
1649 | |
1650 void TestRunner::Reset() { | |
1651 is_web_platform_tests_mode_ = false; | |
1652 will_navigate_ = false; | |
1653 top_loading_frame_ = nullptr; | |
1654 layout_test_runtime_flags_.Reset(); | |
1655 mock_screen_orientation_client_->ResetData(); | |
1656 drag_image_.reset(); | |
1657 | |
1658 WebSecurityPolicy::resetOriginAccessWhitelists(); | |
1659 #if defined(__linux__) || defined(ANDROID) | |
1660 WebFontRendering::setSubpixelPositioning(false); | |
1661 #endif | |
1662 | |
1663 if (delegate_) { | |
1664 // Reset the default quota for each origin to 5MB | |
1665 delegate_->SetDatabaseQuota(5 * 1024 * 1024); | |
1666 delegate_->SetDeviceColorProfile("reset"); | |
1667 delegate_->SetDeviceScaleFactor(GetDefaultDeviceScaleFactor()); | |
1668 delegate_->SetBlockThirdPartyCookies(true); | |
1669 delegate_->SetLocale(""); | |
1670 delegate_->UseUnfortunateSynchronousResizeMode(false); | |
1671 delegate_->DisableAutoResizeMode(WebSize()); | |
1672 delegate_->DeleteAllCookies(); | |
1673 delegate_->SetBluetoothManualChooser(false); | |
1674 delegate_->ResetPermissions(); | |
1675 ResetDeviceLight(); | |
1676 } | |
1677 | |
1678 dump_as_audio_ = false; | |
1679 dump_back_forward_list_ = false; | |
1680 test_repaint_ = false; | |
1681 sweep_horizontally_ = false; | |
1682 midi_accessor_result_ = midi::mojom::Result::OK; | |
1683 | |
1684 http_headers_to_clear_.clear(); | |
1685 | |
1686 platform_name_ = "chromium"; | |
1687 tooltip_text_ = std::string(); | |
1688 web_history_item_count_ = 0; | |
1689 | |
1690 SetUseMockTheme(true); | |
1691 | |
1692 weak_factory_.InvalidateWeakPtrs(); | |
1693 work_queue_.Reset(); | |
1694 | |
1695 if (close_remaining_windows_ && delegate_) | |
1696 delegate_->CloseRemainingWindows(); | |
1697 else | |
1698 close_remaining_windows_ = true; | |
1699 | |
1700 spellcheck_->Reset(); | |
1701 } | |
1702 | |
1703 void TestRunner::SetTestIsRunning(bool running) { | |
1704 test_is_running_ = running; | |
1705 } | |
1706 | |
1707 bool TestRunner::shouldDumpEditingCallbacks() const { | |
1708 return layout_test_runtime_flags_.dump_editting_callbacks(); | |
1709 } | |
1710 | |
1711 void TestRunner::setShouldDumpAsText(bool value) { | |
1712 layout_test_runtime_flags_.set_dump_as_text(value); | |
1713 OnLayoutTestRuntimeFlagsChanged(); | |
1714 } | |
1715 | |
1716 void TestRunner::setShouldDumpAsMarkup(bool value) { | |
1717 layout_test_runtime_flags_.set_dump_as_markup(value); | |
1718 OnLayoutTestRuntimeFlagsChanged(); | |
1719 } | |
1720 | |
1721 bool TestRunner::shouldDumpAsCustomText() const { | |
1722 return layout_test_runtime_flags_.has_custom_text_output(); | |
1723 } | |
1724 | |
1725 std::string TestRunner::customDumpText() const { | |
1726 return layout_test_runtime_flags_.custom_text_output(); | |
1727 } | |
1728 | |
1729 void TestRunner::setCustomTextOutput(const std::string& text) { | |
1730 layout_test_runtime_flags_.set_custom_text_output(text); | |
1731 layout_test_runtime_flags_.set_has_custom_text_output(true); | |
1732 OnLayoutTestRuntimeFlagsChanged(); | |
1733 } | |
1734 | |
1735 bool TestRunner::ShouldGeneratePixelResults() { | |
1736 CheckResponseMimeType(); | |
1737 return layout_test_runtime_flags_.generate_pixel_results(); | |
1738 } | |
1739 | |
1740 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const { | |
1741 return layout_test_runtime_flags_.stay_on_page_after_handling_before_unload(); | |
1742 } | |
1743 | |
1744 | |
1745 void TestRunner::setShouldGeneratePixelResults(bool value) { | |
1746 layout_test_runtime_flags_.set_generate_pixel_results(value); | |
1747 OnLayoutTestRuntimeFlagsChanged(); | |
1748 } | |
1749 | |
1750 bool TestRunner::ShouldDumpAsAudio() const { | |
1751 return dump_as_audio_; | |
1752 } | |
1753 | |
1754 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const { | |
1755 *buffer_view = audio_data_; | |
1756 } | |
1757 | |
1758 bool TestRunner::IsRecursiveLayoutDumpRequested() { | |
1759 CheckResponseMimeType(); | |
1760 return layout_test_runtime_flags_.dump_child_frames(); | |
1761 } | |
1762 | |
1763 std::string TestRunner::DumpLayout(blink::WebLocalFrame* frame) { | |
1764 CheckResponseMimeType(); | |
1765 return ::test_runner::DumpLayout(frame, layout_test_runtime_flags_); | |
1766 } | |
1767 | |
1768 void TestRunner::DumpPixelsAsync( | |
1769 blink::WebView* web_view, | |
1770 const base::Callback<void(const SkBitmap&)>& callback) { | |
1771 if (layout_test_runtime_flags_.dump_drag_image()) { | |
1772 if (drag_image_.isNull()) { | |
1773 // This means the test called dumpDragImage but did not initiate a drag. | |
1774 // Return a blank image so that the test fails. | |
1775 SkBitmap bitmap; | |
1776 bitmap.allocN32Pixels(1, 1); | |
1777 { | |
1778 SkAutoLockPixels lock(bitmap); | |
1779 bitmap.eraseColor(0); | |
1780 } | |
1781 callback.Run(bitmap); | |
1782 return; | |
1783 } | |
1784 | |
1785 callback.Run(drag_image_.getSkBitmap()); | |
1786 return; | |
1787 } | |
1788 | |
1789 test_runner::DumpPixelsAsync(web_view, layout_test_runtime_flags_, | |
1790 delegate_->GetDeviceScaleFactor(), callback); | |
1791 } | |
1792 | |
1793 void TestRunner::ReplicateLayoutTestRuntimeFlagsChanges( | |
1794 const base::DictionaryValue& changed_values) { | |
1795 if (test_is_running_) | |
1796 layout_test_runtime_flags_.tracked_dictionary().ApplyUntrackedChanges( | |
1797 changed_values); | |
1798 } | |
1799 | |
1800 bool TestRunner::HasCustomTextDump(std::string* custom_text_dump) const { | |
1801 if (shouldDumpAsCustomText()) { | |
1802 *custom_text_dump = customDumpText(); | |
1803 return true; | |
1804 } | |
1805 | |
1806 return false; | |
1807 } | |
1808 | |
1809 bool TestRunner::shouldDumpFrameLoadCallbacks() const { | |
1810 return test_is_running_ && | |
1811 layout_test_runtime_flags_.dump_frame_load_callbacks(); | |
1812 } | |
1813 | |
1814 void TestRunner::setShouldDumpFrameLoadCallbacks(bool value) { | |
1815 layout_test_runtime_flags_.set_dump_frame_load_callbacks(value); | |
1816 OnLayoutTestRuntimeFlagsChanged(); | |
1817 } | |
1818 | |
1819 bool TestRunner::shouldDumpPingLoaderCallbacks() const { | |
1820 return test_is_running_ && | |
1821 layout_test_runtime_flags_.dump_ping_loader_callbacks(); | |
1822 } | |
1823 | |
1824 void TestRunner::setShouldEnableViewSource(bool value) { | |
1825 // TODO(lukasza): This flag should be 1) replicated across OOPIFs and | |
1826 // 2) applied to all views, not just the main window view. | |
1827 | |
1828 // Path-based test config is trigerred by BlinkTestRunner, when |main_view_| | |
1829 // is guaranteed to exist at this point. | |
1830 DCHECK(main_view_); | |
1831 | |
1832 main_view_->mainFrame()->enableViewSourceMode(value); | |
1833 } | |
1834 | |
1835 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const { | |
1836 return test_is_running_ && | |
1837 layout_test_runtime_flags_.dump_user_gesture_in_frame_load_callbacks(); | |
1838 } | |
1839 | |
1840 bool TestRunner::shouldDumpTitleChanges() const { | |
1841 return layout_test_runtime_flags_.dump_title_changes(); | |
1842 } | |
1843 | |
1844 bool TestRunner::shouldDumpIconChanges() const { | |
1845 return layout_test_runtime_flags_.dump_icon_changes(); | |
1846 } | |
1847 | |
1848 bool TestRunner::shouldDumpCreateView() const { | |
1849 return layout_test_runtime_flags_.dump_create_view(); | |
1850 } | |
1851 | |
1852 bool TestRunner::canOpenWindows() const { | |
1853 return layout_test_runtime_flags_.can_open_windows(); | |
1854 } | |
1855 | |
1856 bool TestRunner::shouldDumpResourceLoadCallbacks() const { | |
1857 return test_is_running_ && | |
1858 layout_test_runtime_flags_.dump_resource_load_callbacks(); | |
1859 } | |
1860 | |
1861 bool TestRunner::shouldDumpResourceResponseMIMETypes() const { | |
1862 return test_is_running_ && | |
1863 layout_test_runtime_flags_.dump_resource_response_mime_types(); | |
1864 } | |
1865 | |
1866 WebContentSettingsClient* TestRunner::GetWebContentSettings() const { | |
1867 return mock_content_settings_client_.get(); | |
1868 } | |
1869 | |
1870 void TestRunner::InitializeWebViewWithMocks(blink::WebView* web_view) { | |
1871 web_view->setSpellCheckClient(spellcheck_.get()); | |
1872 web_view->setCredentialManagerClient(credential_manager_client_.get()); | |
1873 } | |
1874 | |
1875 bool TestRunner::shouldDumpStatusCallbacks() const { | |
1876 return layout_test_runtime_flags_.dump_window_status_changes(); | |
1877 } | |
1878 | |
1879 bool TestRunner::shouldDumpSpellCheckCallbacks() const { | |
1880 return layout_test_runtime_flags_.dump_spell_check_callbacks(); | |
1881 } | |
1882 | |
1883 bool TestRunner::ShouldDumpBackForwardList() const { | |
1884 return dump_back_forward_list_; | |
1885 } | |
1886 | |
1887 bool TestRunner::isPrinting() const { | |
1888 return layout_test_runtime_flags_.is_printing(); | |
1889 } | |
1890 | |
1891 bool TestRunner::shouldWaitUntilExternalURLLoad() const { | |
1892 return layout_test_runtime_flags_.wait_until_external_url_load(); | |
1893 } | |
1894 | |
1895 const std::set<std::string>* TestRunner::httpHeadersToClear() const { | |
1896 return &http_headers_to_clear_; | |
1897 } | |
1898 | |
1899 bool TestRunner::IsFramePartOfMainTestWindow(blink::WebFrame* frame) const { | |
1900 return test_is_running_ && frame->top()->view() == main_view_; | |
1901 } | |
1902 | |
1903 void TestRunner::OnNavigationBegin(WebFrame* frame) { | |
1904 if (IsFramePartOfMainTestWindow(frame)) | |
1905 will_navigate_ = true; | |
1906 } | |
1907 | |
1908 bool TestRunner::tryToSetTopLoadingFrame(WebFrame* frame) { | |
1909 will_navigate_ = false; | |
1910 if (!IsFramePartOfMainTestWindow(frame)) | |
1911 return false; | |
1912 | |
1913 if (top_loading_frame_ || layout_test_runtime_flags_.have_top_loading_frame()) | |
1914 return false; | |
1915 | |
1916 top_loading_frame_ = frame; | |
1917 layout_test_runtime_flags_.set_have_top_loading_frame(true); | |
1918 OnLayoutTestRuntimeFlagsChanged(); | |
1919 return true; | |
1920 } | |
1921 | |
1922 bool TestRunner::tryToClearTopLoadingFrame(WebFrame* frame) { | |
1923 will_navigate_ = false; | |
1924 if (!IsFramePartOfMainTestWindow(frame)) | |
1925 return false; | |
1926 | |
1927 if (frame != top_loading_frame_) | |
1928 return false; | |
1929 | |
1930 top_loading_frame_ = nullptr; | |
1931 DCHECK(layout_test_runtime_flags_.have_top_loading_frame()); | |
1932 layout_test_runtime_flags_.set_have_top_loading_frame(false); | |
1933 OnLayoutTestRuntimeFlagsChanged(); | |
1934 | |
1935 LocationChangeDone(); | |
1936 return true; | |
1937 } | |
1938 | |
1939 WebFrame* TestRunner::topLoadingFrame() const { | |
1940 return top_loading_frame_; | |
1941 } | |
1942 | |
1943 WebFrame* TestRunner::mainFrame() const { | |
1944 return main_view_->mainFrame(); | |
1945 } | |
1946 | |
1947 void TestRunner::policyDelegateDone() { | |
1948 DCHECK(layout_test_runtime_flags_.wait_until_done()); | |
1949 delegate_->TestFinished(); | |
1950 layout_test_runtime_flags_.set_wait_until_done(false); | |
1951 OnLayoutTestRuntimeFlagsChanged(); | |
1952 } | |
1953 | |
1954 bool TestRunner::policyDelegateEnabled() const { | |
1955 return layout_test_runtime_flags_.policy_delegate_enabled(); | |
1956 } | |
1957 | |
1958 bool TestRunner::policyDelegateIsPermissive() const { | |
1959 return layout_test_runtime_flags_.policy_delegate_is_permissive(); | |
1960 } | |
1961 | |
1962 bool TestRunner::policyDelegateShouldNotifyDone() const { | |
1963 return layout_test_runtime_flags_.policy_delegate_should_notify_done(); | |
1964 } | |
1965 | |
1966 void TestRunner::setToolTipText(const WebString& text) { | |
1967 tooltip_text_ = text.utf8(); | |
1968 } | |
1969 | |
1970 void TestRunner::setDragImage( | |
1971 const blink::WebImage& drag_image) { | |
1972 if (layout_test_runtime_flags_.dump_drag_image()) { | |
1973 if (drag_image_.isNull()) | |
1974 drag_image_ = drag_image; | |
1975 } | |
1976 } | |
1977 | |
1978 bool TestRunner::shouldDumpNavigationPolicy() const { | |
1979 return layout_test_runtime_flags_.dump_navigation_policy(); | |
1980 } | |
1981 | |
1982 midi::mojom::Result TestRunner::midiAccessorResult() { | |
1983 return midi_accessor_result_; | |
1984 } | |
1985 | |
1986 void TestRunner::ClearDevToolsLocalStorage() { | |
1987 delegate_->ClearDevToolsLocalStorage(); | |
1988 } | |
1989 | |
1990 void TestRunner::SetV8CacheDisabled(bool disabled) { | |
1991 if (!main_view_) { | |
1992 disable_v8_cache_ = disabled; | |
1993 return; | |
1994 } | |
1995 main_view_->settings()->setV8CacheOptions(disabled ? | |
1996 blink::WebSettings::V8CacheOptionsNone : | |
1997 blink::WebSettings::V8CacheOptionsDefault); | |
1998 } | |
1999 | |
2000 void TestRunner::ShowDevTools(const std::string& settings, | |
2001 const std::string& frontend_url) { | |
2002 delegate_->ShowDevTools(settings, frontend_url); | |
2003 } | |
2004 | |
2005 class WorkItemBackForward : public TestRunner::WorkItem { | |
2006 public: | |
2007 WorkItemBackForward(int distance) : distance_(distance) {} | |
2008 | |
2009 bool Run(WebTestDelegate* delegate, WebView*) override { | |
2010 delegate->GoToOffset(distance_); | |
2011 return true; // FIXME: Did it really start a navigation? | |
2012 } | |
2013 | |
2014 private: | |
2015 int distance_; | |
2016 }; | |
2017 | |
2018 void TestRunner::WaitUntilDone() { | |
2019 layout_test_runtime_flags_.set_wait_until_done(true); | |
2020 OnLayoutTestRuntimeFlagsChanged(); | |
2021 } | |
2022 | |
2023 void TestRunner::QueueBackNavigation(int how_far_back) { | |
2024 work_queue_.AddWork(new WorkItemBackForward(-how_far_back)); | |
2025 } | |
2026 | |
2027 void TestRunner::QueueForwardNavigation(int how_far_forward) { | |
2028 work_queue_.AddWork(new WorkItemBackForward(how_far_forward)); | |
2029 } | |
2030 | |
2031 class WorkItemReload : public TestRunner::WorkItem { | |
2032 public: | |
2033 bool Run(WebTestDelegate* delegate, WebView*) override { | |
2034 delegate->Reload(); | |
2035 return true; | |
2036 } | |
2037 }; | |
2038 | |
2039 void TestRunner::QueueReload() { | |
2040 work_queue_.AddWork(new WorkItemReload()); | |
2041 } | |
2042 | |
2043 class WorkItemLoadingScript : public TestRunner::WorkItem { | |
2044 public: | |
2045 WorkItemLoadingScript(const std::string& script) | |
2046 : script_(script) {} | |
2047 | |
2048 bool Run(WebTestDelegate*, WebView* web_view) override { | |
2049 web_view->mainFrame()->executeScript( | |
2050 WebScriptSource(WebString::fromUTF8(script_))); | |
2051 return true; // FIXME: Did it really start a navigation? | |
2052 } | |
2053 | |
2054 private: | |
2055 std::string script_; | |
2056 }; | |
2057 | |
2058 void TestRunner::QueueLoadingScript(const std::string& script) { | |
2059 work_queue_.AddWork(new WorkItemLoadingScript(script)); | |
2060 } | |
2061 | |
2062 class WorkItemNonLoadingScript : public TestRunner::WorkItem { | |
2063 public: | |
2064 WorkItemNonLoadingScript(const std::string& script) | |
2065 : script_(script) {} | |
2066 | |
2067 bool Run(WebTestDelegate*, WebView* web_view) override { | |
2068 web_view->mainFrame()->executeScript( | |
2069 WebScriptSource(WebString::fromUTF8(script_))); | |
2070 return false; | |
2071 } | |
2072 | |
2073 private: | |
2074 std::string script_; | |
2075 }; | |
2076 | |
2077 void TestRunner::QueueNonLoadingScript(const std::string& script) { | |
2078 work_queue_.AddWork(new WorkItemNonLoadingScript(script)); | |
2079 } | |
2080 | |
2081 class WorkItemLoad : public TestRunner::WorkItem { | |
2082 public: | |
2083 WorkItemLoad(const WebURL& url, const std::string& target) | |
2084 : url_(url), target_(target) {} | |
2085 | |
2086 bool Run(WebTestDelegate* delegate, WebView*) override { | |
2087 delegate->LoadURLForFrame(url_, target_); | |
2088 return true; // FIXME: Did it really start a navigation? | |
2089 } | |
2090 | |
2091 private: | |
2092 WebURL url_; | |
2093 std::string target_; | |
2094 }; | |
2095 | |
2096 void TestRunner::QueueLoad(const std::string& url, const std::string& target) { | |
2097 if (!main_view_) | |
2098 return; | |
2099 | |
2100 // FIXME: Implement WebURL::resolve() and avoid GURL. | |
2101 GURL current_url = main_view_->mainFrame()->document().url(); | |
2102 GURL full_url = current_url.Resolve(url); | |
2103 work_queue_.AddWork(new WorkItemLoad(full_url, target)); | |
2104 } | |
2105 | |
2106 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) { | |
2107 bool value; | |
2108 args->GetNext(&value); | |
2109 layout_test_runtime_flags_.set_policy_delegate_enabled(value); | |
2110 | |
2111 if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean()) { | |
2112 args->GetNext(&value); | |
2113 layout_test_runtime_flags_.set_policy_delegate_is_permissive(value); | |
2114 } | |
2115 | |
2116 OnLayoutTestRuntimeFlagsChanged(); | |
2117 } | |
2118 | |
2119 void TestRunner::WaitForPolicyDelegate() { | |
2120 layout_test_runtime_flags_.set_policy_delegate_enabled(true); | |
2121 layout_test_runtime_flags_.set_policy_delegate_should_notify_done(true); | |
2122 layout_test_runtime_flags_.set_wait_until_done(true); | |
2123 OnLayoutTestRuntimeFlagsChanged(); | |
2124 } | |
2125 | |
2126 int TestRunner::WindowCount() { | |
2127 return test_interfaces_->GetWindowList().size(); | |
2128 } | |
2129 | |
2130 void TestRunner::SetCloseRemainingWindowsWhenComplete( | |
2131 bool close_remaining_windows) { | |
2132 close_remaining_windows_ = close_remaining_windows; | |
2133 } | |
2134 | |
2135 void TestRunner::ResetTestHelperControllers() { | |
2136 test_interfaces_->ResetTestHelperControllers(); | |
2137 } | |
2138 | |
2139 void TestRunner::AddOriginAccessWhitelistEntry( | |
2140 const std::string& source_origin, | |
2141 const std::string& destination_protocol, | |
2142 const std::string& destination_host, | |
2143 bool allow_destination_subdomains) { | |
2144 WebURL url((GURL(source_origin))); | |
2145 if (!url.isValid()) | |
2146 return; | |
2147 | |
2148 WebSecurityPolicy::addOriginAccessWhitelistEntry( | |
2149 url, | |
2150 WebString::fromUTF8(destination_protocol), | |
2151 WebString::fromUTF8(destination_host), | |
2152 allow_destination_subdomains); | |
2153 } | |
2154 | |
2155 void TestRunner::RemoveOriginAccessWhitelistEntry( | |
2156 const std::string& source_origin, | |
2157 const std::string& destination_protocol, | |
2158 const std::string& destination_host, | |
2159 bool allow_destination_subdomains) { | |
2160 WebURL url((GURL(source_origin))); | |
2161 if (!url.isValid()) | |
2162 return; | |
2163 | |
2164 WebSecurityPolicy::removeOriginAccessWhitelistEntry( | |
2165 url, | |
2166 WebString::fromUTF8(destination_protocol), | |
2167 WebString::fromUTF8(destination_host), | |
2168 allow_destination_subdomains); | |
2169 } | |
2170 | |
2171 void TestRunner::SetTextSubpixelPositioning(bool value) { | |
2172 #if defined(__linux__) || defined(ANDROID) | |
2173 // Since FontConfig doesn't provide a variable to control subpixel | |
2174 // positioning, we'll fall back to setting it globally for all fonts. | |
2175 WebFontRendering::setSubpixelPositioning(value); | |
2176 #endif | |
2177 } | |
2178 | |
2179 void TestRunner::UseUnfortunateSynchronousResizeMode() { | |
2180 delegate_->UseUnfortunateSynchronousResizeMode(true); | |
2181 } | |
2182 | |
2183 bool TestRunner::EnableAutoResizeMode(int min_width, | |
2184 int min_height, | |
2185 int max_width, | |
2186 int max_height) { | |
2187 WebSize min_size(min_width, min_height); | |
2188 WebSize max_size(max_width, max_height); | |
2189 delegate_->EnableAutoResizeMode(min_size, max_size); | |
2190 return true; | |
2191 } | |
2192 | |
2193 bool TestRunner::DisableAutoResizeMode(int new_width, int new_height) { | |
2194 WebSize new_size(new_width, new_height); | |
2195 delegate_->DisableAutoResizeMode(new_size); | |
2196 return true; | |
2197 } | |
2198 | |
2199 void TestRunner::SetMockDeviceLight(double value) { | |
2200 delegate_->SetDeviceLightData(value); | |
2201 } | |
2202 | |
2203 void TestRunner::ResetDeviceLight() { | |
2204 delegate_->SetDeviceLightData(-1); | |
2205 } | |
2206 | |
2207 void TestRunner::SetMockDeviceMotion( | |
2208 bool has_acceleration_x, double acceleration_x, | |
2209 bool has_acceleration_y, double acceleration_y, | |
2210 bool has_acceleration_z, double acceleration_z, | |
2211 bool has_acceleration_including_gravity_x, | |
2212 double acceleration_including_gravity_x, | |
2213 bool has_acceleration_including_gravity_y, | |
2214 double acceleration_including_gravity_y, | |
2215 bool has_acceleration_including_gravity_z, | |
2216 double acceleration_including_gravity_z, | |
2217 bool has_rotation_rate_alpha, double rotation_rate_alpha, | |
2218 bool has_rotation_rate_beta, double rotation_rate_beta, | |
2219 bool has_rotation_rate_gamma, double rotation_rate_gamma, | |
2220 double interval) { | |
2221 WebDeviceMotionData motion; | |
2222 | |
2223 // acceleration | |
2224 motion.hasAccelerationX = has_acceleration_x; | |
2225 motion.accelerationX = acceleration_x; | |
2226 motion.hasAccelerationY = has_acceleration_y; | |
2227 motion.accelerationY = acceleration_y; | |
2228 motion.hasAccelerationZ = has_acceleration_z; | |
2229 motion.accelerationZ = acceleration_z; | |
2230 | |
2231 // accelerationIncludingGravity | |
2232 motion.hasAccelerationIncludingGravityX = | |
2233 has_acceleration_including_gravity_x; | |
2234 motion.accelerationIncludingGravityX = acceleration_including_gravity_x; | |
2235 motion.hasAccelerationIncludingGravityY = | |
2236 has_acceleration_including_gravity_y; | |
2237 motion.accelerationIncludingGravityY = acceleration_including_gravity_y; | |
2238 motion.hasAccelerationIncludingGravityZ = | |
2239 has_acceleration_including_gravity_z; | |
2240 motion.accelerationIncludingGravityZ = acceleration_including_gravity_z; | |
2241 | |
2242 // rotationRate | |
2243 motion.hasRotationRateAlpha = has_rotation_rate_alpha; | |
2244 motion.rotationRateAlpha = rotation_rate_alpha; | |
2245 motion.hasRotationRateBeta = has_rotation_rate_beta; | |
2246 motion.rotationRateBeta = rotation_rate_beta; | |
2247 motion.hasRotationRateGamma = has_rotation_rate_gamma; | |
2248 motion.rotationRateGamma = rotation_rate_gamma; | |
2249 | |
2250 // interval | |
2251 motion.interval = interval; | |
2252 | |
2253 delegate_->SetDeviceMotionData(motion); | |
2254 } | |
2255 | |
2256 void TestRunner::SetMockDeviceOrientation(bool has_alpha, double alpha, | |
2257 bool has_beta, double beta, | |
2258 bool has_gamma, double gamma, | |
2259 bool absolute) { | |
2260 WebDeviceOrientationData orientation; | |
2261 | |
2262 // alpha | |
2263 orientation.hasAlpha = has_alpha; | |
2264 orientation.alpha = alpha; | |
2265 | |
2266 // beta | |
2267 orientation.hasBeta = has_beta; | |
2268 orientation.beta = beta; | |
2269 | |
2270 // gamma | |
2271 orientation.hasGamma = has_gamma; | |
2272 orientation.gamma = gamma; | |
2273 | |
2274 // absolute | |
2275 orientation.absolute = absolute; | |
2276 | |
2277 delegate_->SetDeviceOrientationData(orientation); | |
2278 } | |
2279 | |
2280 MockScreenOrientationClient* TestRunner::getMockScreenOrientationClient() { | |
2281 return mock_screen_orientation_client_.get(); | |
2282 } | |
2283 | |
2284 MockWebUserMediaClient* TestRunner::getMockWebUserMediaClient() { | |
2285 if (!user_media_client_.get()) | |
2286 user_media_client_.reset(new MockWebUserMediaClient(delegate_)); | |
2287 return user_media_client_.get(); | |
2288 } | |
2289 | |
2290 MockWebSpeechRecognizer* TestRunner::getMockWebSpeechRecognizer() { | |
2291 if (!speech_recognizer_.get()) { | |
2292 speech_recognizer_.reset(new MockWebSpeechRecognizer()); | |
2293 speech_recognizer_->SetDelegate(delegate_); | |
2294 } | |
2295 return speech_recognizer_.get(); | |
2296 } | |
2297 | |
2298 void TestRunner::SetMockScreenOrientation(const std::string& orientation_str) { | |
2299 blink::WebScreenOrientationType orientation; | |
2300 | |
2301 if (orientation_str == "portrait-primary") { | |
2302 orientation = WebScreenOrientationPortraitPrimary; | |
2303 } else if (orientation_str == "portrait-secondary") { | |
2304 orientation = WebScreenOrientationPortraitSecondary; | |
2305 } else if (orientation_str == "landscape-primary") { | |
2306 orientation = WebScreenOrientationLandscapePrimary; | |
2307 } else { | |
2308 DCHECK_EQ("landscape-secondary", orientation_str); | |
2309 orientation = WebScreenOrientationLandscapeSecondary; | |
2310 } | |
2311 | |
2312 for (WebViewTestProxyBase* window : test_interfaces_->GetWindowList()) { | |
2313 WebFrame* main_frame = window->web_view()->mainFrame(); | |
2314 // TODO(lukasza): Need to make this work for remote frames. | |
2315 if (main_frame->isWebLocalFrame()) { | |
2316 mock_screen_orientation_client_->UpdateDeviceOrientation( | |
2317 main_frame->toWebLocalFrame(), orientation); | |
2318 } | |
2319 } | |
2320 } | |
2321 | |
2322 void TestRunner::DisableMockScreenOrientation() { | |
2323 mock_screen_orientation_client_->SetDisabled(true); | |
2324 } | |
2325 | |
2326 void TestRunner::DidOpenChooser() { | |
2327 chooser_count_++; | |
2328 } | |
2329 | |
2330 void TestRunner::DidCloseChooser() { | |
2331 chooser_count_--; | |
2332 DCHECK_LE(0, chooser_count_); | |
2333 } | |
2334 | |
2335 void TestRunner::SetPopupBlockingEnabled(bool block_popups) { | |
2336 delegate_->Preferences()->java_script_can_open_windows_automatically = | |
2337 !block_popups; | |
2338 delegate_->ApplyPreferences(); | |
2339 } | |
2340 | |
2341 void TestRunner::SetJavaScriptCanAccessClipboard(bool can_access) { | |
2342 delegate_->Preferences()->java_script_can_access_clipboard = can_access; | |
2343 delegate_->ApplyPreferences(); | |
2344 } | |
2345 | |
2346 void TestRunner::SetXSSAuditorEnabled(bool enabled) { | |
2347 delegate_->Preferences()->xss_auditor_enabled = enabled; | |
2348 delegate_->ApplyPreferences(); | |
2349 } | |
2350 | |
2351 void TestRunner::SetAllowUniversalAccessFromFileURLs(bool allow) { | |
2352 delegate_->Preferences()->allow_universal_access_from_file_urls = allow; | |
2353 delegate_->ApplyPreferences(); | |
2354 } | |
2355 | |
2356 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) { | |
2357 delegate_->Preferences()->allow_file_access_from_file_urls = allow; | |
2358 delegate_->ApplyPreferences(); | |
2359 } | |
2360 | |
2361 void TestRunner::OverridePreference(const std::string& key, | |
2362 v8::Local<v8::Value> value) { | |
2363 TestPreferences* prefs = delegate_->Preferences(); | |
2364 if (key == "WebKitDefaultFontSize") { | |
2365 prefs->default_font_size = value->Int32Value(); | |
2366 } else if (key == "WebKitMinimumFontSize") { | |
2367 prefs->minimum_font_size = value->Int32Value(); | |
2368 } else if (key == "WebKitDefaultTextEncodingName") { | |
2369 v8::Isolate* isolate = blink::mainThreadIsolate(); | |
2370 prefs->default_text_encoding_name = | |
2371 V8StringToWebString(value->ToString(isolate)); | |
2372 } else if (key == "WebKitJavaScriptEnabled") { | |
2373 prefs->java_script_enabled = value->BooleanValue(); | |
2374 } else if (key == "WebKitSupportsMultipleWindows") { | |
2375 prefs->supports_multiple_windows = value->BooleanValue(); | |
2376 } else if (key == "WebKitDisplayImagesKey") { | |
2377 prefs->loads_images_automatically = value->BooleanValue(); | |
2378 } else if (key == "WebKitPluginsEnabled") { | |
2379 prefs->plugins_enabled = value->BooleanValue(); | |
2380 } else if (key == "WebKitTabToLinksPreferenceKey") { | |
2381 prefs->tabs_to_links = value->BooleanValue(); | |
2382 } else if (key == "WebKitWebGLEnabled") { | |
2383 prefs->experimental_webgl_enabled = value->BooleanValue(); | |
2384 } else if (key == "WebKitCSSGridLayoutEnabled") { | |
2385 prefs->experimental_css_grid_layout_enabled = value->BooleanValue(); | |
2386 } else if (key == "WebKitHyperlinkAuditingEnabled") { | |
2387 prefs->hyperlink_auditing_enabled = value->BooleanValue(); | |
2388 } else if (key == "WebKitEnableCaretBrowsing") { | |
2389 prefs->caret_browsing_enabled = value->BooleanValue(); | |
2390 } else if (key == "WebKitAllowRunningInsecureContent") { | |
2391 prefs->allow_running_of_insecure_content = value->BooleanValue(); | |
2392 } else if (key == "WebKitDisableReadingFromCanvas") { | |
2393 prefs->disable_reading_from_canvas = value->BooleanValue(); | |
2394 } else if (key == "WebKitStrictMixedContentChecking") { | |
2395 prefs->strict_mixed_content_checking = value->BooleanValue(); | |
2396 } else if (key == "WebKitStrictPowerfulFeatureRestrictions") { | |
2397 prefs->strict_powerful_feature_restrictions = value->BooleanValue(); | |
2398 } else if (key == "WebKitShouldRespectImageOrientation") { | |
2399 prefs->should_respect_image_orientation = value->BooleanValue(); | |
2400 } else if (key == "WebKitWebSecurityEnabled") { | |
2401 prefs->web_security_enabled = value->BooleanValue(); | |
2402 } else if (key == "WebKitSpatialNavigationEnabled") { | |
2403 prefs->spatial_navigation_enabled = value->BooleanValue(); | |
2404 } else { | |
2405 std::string message("Invalid name for preference: "); | |
2406 message.append(key); | |
2407 delegate_->PrintMessage(std::string("CONSOLE MESSAGE: ") + message + "\n"); | |
2408 } | |
2409 delegate_->ApplyPreferences(); | |
2410 } | |
2411 | |
2412 std::string TestRunner::GetAcceptLanguages() const { | |
2413 return layout_test_runtime_flags_.accept_languages(); | |
2414 } | |
2415 | |
2416 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) { | |
2417 if (accept_languages == GetAcceptLanguages()) | |
2418 return; | |
2419 | |
2420 layout_test_runtime_flags_.set_accept_languages(accept_languages); | |
2421 OnLayoutTestRuntimeFlagsChanged(); | |
2422 | |
2423 for (WebViewTestProxyBase* window : test_interfaces_->GetWindowList()) | |
2424 window->web_view()->acceptLanguagesChanged(); | |
2425 } | |
2426 | |
2427 void TestRunner::SetPluginsEnabled(bool enabled) { | |
2428 delegate_->Preferences()->plugins_enabled = enabled; | |
2429 delegate_->ApplyPreferences(); | |
2430 } | |
2431 | |
2432 void TestRunner::DumpEditingCallbacks() { | |
2433 layout_test_runtime_flags_.set_dump_editting_callbacks(true); | |
2434 OnLayoutTestRuntimeFlagsChanged(); | |
2435 } | |
2436 | |
2437 void TestRunner::DumpAsMarkup() { | |
2438 layout_test_runtime_flags_.set_dump_as_markup(true); | |
2439 layout_test_runtime_flags_.set_generate_pixel_results(false); | |
2440 OnLayoutTestRuntimeFlagsChanged(); | |
2441 } | |
2442 | |
2443 void TestRunner::DumpAsText() { | |
2444 layout_test_runtime_flags_.set_dump_as_text(true); | |
2445 layout_test_runtime_flags_.set_generate_pixel_results(false); | |
2446 OnLayoutTestRuntimeFlagsChanged(); | |
2447 } | |
2448 | |
2449 void TestRunner::DumpAsTextWithPixelResults() { | |
2450 layout_test_runtime_flags_.set_dump_as_text(true); | |
2451 layout_test_runtime_flags_.set_generate_pixel_results(true); | |
2452 OnLayoutTestRuntimeFlagsChanged(); | |
2453 } | |
2454 | |
2455 void TestRunner::DumpChildFrameScrollPositions() { | |
2456 layout_test_runtime_flags_.set_dump_child_frame_scroll_positions(true); | |
2457 OnLayoutTestRuntimeFlagsChanged(); | |
2458 } | |
2459 | |
2460 void TestRunner::DumpChildFramesAsMarkup() { | |
2461 layout_test_runtime_flags_.set_dump_child_frames_as_markup(true); | |
2462 OnLayoutTestRuntimeFlagsChanged(); | |
2463 } | |
2464 | |
2465 void TestRunner::DumpChildFramesAsText() { | |
2466 layout_test_runtime_flags_.set_dump_child_frames_as_text(true); | |
2467 OnLayoutTestRuntimeFlagsChanged(); | |
2468 } | |
2469 | |
2470 void TestRunner::DumpIconChanges() { | |
2471 layout_test_runtime_flags_.set_dump_icon_changes(true); | |
2472 OnLayoutTestRuntimeFlagsChanged(); | |
2473 } | |
2474 | |
2475 void TestRunner::SetAudioData(const gin::ArrayBufferView& view) { | |
2476 unsigned char* bytes = static_cast<unsigned char*>(view.bytes()); | |
2477 audio_data_.resize(view.num_bytes()); | |
2478 std::copy(bytes, bytes + view.num_bytes(), audio_data_.begin()); | |
2479 dump_as_audio_ = true; | |
2480 } | |
2481 | |
2482 void TestRunner::DumpFrameLoadCallbacks() { | |
2483 layout_test_runtime_flags_.set_dump_frame_load_callbacks(true); | |
2484 OnLayoutTestRuntimeFlagsChanged(); | |
2485 } | |
2486 | |
2487 void TestRunner::DumpPingLoaderCallbacks() { | |
2488 layout_test_runtime_flags_.set_dump_ping_loader_callbacks(true); | |
2489 OnLayoutTestRuntimeFlagsChanged(); | |
2490 } | |
2491 | |
2492 void TestRunner::DumpUserGestureInFrameLoadCallbacks() { | |
2493 layout_test_runtime_flags_.set_dump_user_gesture_in_frame_load_callbacks( | |
2494 true); | |
2495 OnLayoutTestRuntimeFlagsChanged(); | |
2496 } | |
2497 | |
2498 void TestRunner::DumpTitleChanges() { | |
2499 layout_test_runtime_flags_.set_dump_title_changes(true); | |
2500 OnLayoutTestRuntimeFlagsChanged(); | |
2501 } | |
2502 | |
2503 void TestRunner::DumpCreateView() { | |
2504 layout_test_runtime_flags_.set_dump_create_view(true); | |
2505 OnLayoutTestRuntimeFlagsChanged(); | |
2506 } | |
2507 | |
2508 void TestRunner::SetCanOpenWindows() { | |
2509 layout_test_runtime_flags_.set_can_open_windows(true); | |
2510 OnLayoutTestRuntimeFlagsChanged(); | |
2511 } | |
2512 | |
2513 void TestRunner::DumpResourceLoadCallbacks() { | |
2514 layout_test_runtime_flags_.set_dump_resource_load_callbacks(true); | |
2515 OnLayoutTestRuntimeFlagsChanged(); | |
2516 } | |
2517 | |
2518 void TestRunner::DumpResourceResponseMIMETypes() { | |
2519 layout_test_runtime_flags_.set_dump_resource_response_mime_types(true); | |
2520 OnLayoutTestRuntimeFlagsChanged(); | |
2521 } | |
2522 | |
2523 void TestRunner::SetImagesAllowed(bool allowed) { | |
2524 layout_test_runtime_flags_.set_images_allowed(allowed); | |
2525 OnLayoutTestRuntimeFlagsChanged(); | |
2526 } | |
2527 | |
2528 void TestRunner::SetScriptsAllowed(bool allowed) { | |
2529 layout_test_runtime_flags_.set_scripts_allowed(allowed); | |
2530 OnLayoutTestRuntimeFlagsChanged(); | |
2531 } | |
2532 | |
2533 void TestRunner::SetStorageAllowed(bool allowed) { | |
2534 layout_test_runtime_flags_.set_storage_allowed(allowed); | |
2535 OnLayoutTestRuntimeFlagsChanged(); | |
2536 } | |
2537 | |
2538 void TestRunner::SetPluginsAllowed(bool allowed) { | |
2539 layout_test_runtime_flags_.set_plugins_allowed(allowed); | |
2540 OnLayoutTestRuntimeFlagsChanged(); | |
2541 } | |
2542 | |
2543 void TestRunner::SetAllowRunningOfInsecureContent(bool allowed) { | |
2544 layout_test_runtime_flags_.set_running_insecure_content_allowed(allowed); | |
2545 OnLayoutTestRuntimeFlagsChanged(); | |
2546 } | |
2547 | |
2548 void TestRunner::SetAutoplayAllowed(bool allowed) { | |
2549 layout_test_runtime_flags_.set_autoplay_allowed(allowed); | |
2550 OnLayoutTestRuntimeFlagsChanged(); | |
2551 } | |
2552 | |
2553 void TestRunner::DumpPermissionClientCallbacks() { | |
2554 layout_test_runtime_flags_.set_dump_web_content_settings_client_callbacks( | |
2555 true); | |
2556 OnLayoutTestRuntimeFlagsChanged(); | |
2557 } | |
2558 | |
2559 void TestRunner::SetDisallowedSubresourcePathSuffixes( | |
2560 const std::vector<std::string>& suffixes) { | |
2561 DCHECK(main_view_); | |
2562 main_view_->mainFrame()->dataSource()->setSubresourceFilter( | |
2563 new MockWebDocumentSubresourceFilter(suffixes)); | |
2564 } | |
2565 | |
2566 void TestRunner::DumpWindowStatusChanges() { | |
2567 layout_test_runtime_flags_.set_dump_window_status_changes(true); | |
2568 OnLayoutTestRuntimeFlagsChanged(); | |
2569 } | |
2570 | |
2571 void TestRunner::DumpSpellCheckCallbacks() { | |
2572 layout_test_runtime_flags_.set_dump_spell_check_callbacks(true); | |
2573 OnLayoutTestRuntimeFlagsChanged(); | |
2574 } | |
2575 | |
2576 void TestRunner::DumpBackForwardList() { | |
2577 dump_back_forward_list_ = true; | |
2578 } | |
2579 | |
2580 void TestRunner::DumpSelectionRect() { | |
2581 layout_test_runtime_flags_.set_dump_selection_rect(true); | |
2582 OnLayoutTestRuntimeFlagsChanged(); | |
2583 } | |
2584 | |
2585 void TestRunner::SetPrinting() { | |
2586 layout_test_runtime_flags_.set_is_printing(true); | |
2587 OnLayoutTestRuntimeFlagsChanged(); | |
2588 } | |
2589 | |
2590 void TestRunner::ClearPrinting() { | |
2591 layout_test_runtime_flags_.set_is_printing(false); | |
2592 OnLayoutTestRuntimeFlagsChanged(); | |
2593 } | |
2594 | |
2595 void TestRunner::SetShouldStayOnPageAfterHandlingBeforeUnload(bool value) { | |
2596 layout_test_runtime_flags_.set_stay_on_page_after_handling_before_unload( | |
2597 value); | |
2598 OnLayoutTestRuntimeFlagsChanged(); | |
2599 } | |
2600 | |
2601 void TestRunner::SetWillSendRequestClearHeader(const std::string& header) { | |
2602 if (!header.empty()) | |
2603 http_headers_to_clear_.insert(header); | |
2604 } | |
2605 | |
2606 void TestRunner::SetUseMockTheme(bool use) { | |
2607 use_mock_theme_ = use; | |
2608 blink::setMockThemeEnabledForTest(use); | |
2609 } | |
2610 | |
2611 void TestRunner::ShowWebInspector(const std::string& str, | |
2612 const std::string& frontend_url) { | |
2613 ShowDevTools(str, frontend_url); | |
2614 } | |
2615 | |
2616 void TestRunner::WaitUntilExternalURLLoad() { | |
2617 layout_test_runtime_flags_.set_wait_until_external_url_load(true); | |
2618 OnLayoutTestRuntimeFlagsChanged(); | |
2619 } | |
2620 | |
2621 void TestRunner::DumpDragImage() { | |
2622 layout_test_runtime_flags_.set_dump_drag_image(true); | |
2623 DumpAsTextWithPixelResults(); | |
2624 OnLayoutTestRuntimeFlagsChanged(); | |
2625 } | |
2626 | |
2627 void TestRunner::DumpNavigationPolicy() { | |
2628 layout_test_runtime_flags_.set_dump_navigation_policy(true); | |
2629 OnLayoutTestRuntimeFlagsChanged(); | |
2630 } | |
2631 | |
2632 void TestRunner::SetDumpConsoleMessages(bool value) { | |
2633 layout_test_runtime_flags_.set_dump_console_messages(value); | |
2634 OnLayoutTestRuntimeFlagsChanged(); | |
2635 } | |
2636 | |
2637 void TestRunner::SetDumpJavaScriptDialogs(bool value) { | |
2638 layout_test_runtime_flags_.set_dump_javascript_dialogs(value); | |
2639 OnLayoutTestRuntimeFlagsChanged(); | |
2640 } | |
2641 | |
2642 void TestRunner::SetEffectiveConnectionType( | |
2643 blink::WebEffectiveConnectionType connection_type) { | |
2644 effective_connection_type_ = connection_type; | |
2645 } | |
2646 | |
2647 void TestRunner::SetMockSpellCheckerEnabled(bool enabled) { | |
2648 spellcheck_->SetEnabled(enabled); | |
2649 } | |
2650 | |
2651 bool TestRunner::ShouldDumpConsoleMessages() const { | |
2652 return layout_test_runtime_flags_.dump_console_messages(); | |
2653 } | |
2654 | |
2655 bool TestRunner::ShouldDumpJavaScriptDialogs() const { | |
2656 return layout_test_runtime_flags_.dump_javascript_dialogs(); | |
2657 } | |
2658 | |
2659 void TestRunner::CloseWebInspector() { | |
2660 delegate_->CloseDevTools(); | |
2661 } | |
2662 | |
2663 bool TestRunner::IsChooserShown() { | |
2664 return 0 < chooser_count_; | |
2665 } | |
2666 | |
2667 void TestRunner::EvaluateInWebInspector(int call_id, | |
2668 const std::string& script) { | |
2669 delegate_->EvaluateInWebInspector(call_id, script); | |
2670 } | |
2671 | |
2672 std::string TestRunner::EvaluateInWebInspectorOverlay( | |
2673 const std::string& script) { | |
2674 return delegate_->EvaluateInWebInspectorOverlay(script); | |
2675 } | |
2676 | |
2677 void TestRunner::ClearAllDatabases() { | |
2678 delegate_->ClearAllDatabases(); | |
2679 } | |
2680 | |
2681 void TestRunner::SetDatabaseQuota(int quota) { | |
2682 delegate_->SetDatabaseQuota(quota); | |
2683 } | |
2684 | |
2685 void TestRunner::SetBlockThirdPartyCookies(bool block) { | |
2686 delegate_->SetBlockThirdPartyCookies(block); | |
2687 } | |
2688 | |
2689 void TestRunner::SetFocus(blink::WebView* web_view, bool focus) { | |
2690 if (focus) { | |
2691 if (previously_focused_view_ != web_view) { | |
2692 delegate_->SetFocus(previously_focused_view_, false); | |
2693 delegate_->SetFocus(web_view, true); | |
2694 previously_focused_view_ = web_view; | |
2695 } | |
2696 } else { | |
2697 if (previously_focused_view_ == web_view) { | |
2698 delegate_->SetFocus(web_view, false); | |
2699 previously_focused_view_ = nullptr; | |
2700 } | |
2701 } | |
2702 } | |
2703 | |
2704 std::string TestRunner::PathToLocalResource(const std::string& path) { | |
2705 return delegate_->PathToLocalResource(path); | |
2706 } | |
2707 | |
2708 void TestRunner::SetPermission(const std::string& name, | |
2709 const std::string& value, | |
2710 const GURL& origin, | |
2711 const GURL& embedding_origin) { | |
2712 delegate_->SetPermission(name, value, origin, embedding_origin); | |
2713 } | |
2714 | |
2715 void TestRunner::ResolveBeforeInstallPromptPromise( | |
2716 const std::string& platform) { | |
2717 delegate_->ResolveBeforeInstallPromptPromise(platform); | |
2718 } | |
2719 | |
2720 void TestRunner::SetPOSIXLocale(const std::string& locale) { | |
2721 delegate_->SetLocale(locale); | |
2722 } | |
2723 | |
2724 void TestRunner::SetMIDIAccessorResult(midi::mojom::Result result) { | |
2725 midi_accessor_result_ = result; | |
2726 } | |
2727 | |
2728 void TestRunner::SimulateWebNotificationClick( | |
2729 const std::string& title, | |
2730 int action_index, | |
2731 const base::NullableString16& reply) { | |
2732 delegate_->SimulateWebNotificationClick(title, action_index, reply); | |
2733 } | |
2734 | |
2735 void TestRunner::SimulateWebNotificationClose(const std::string& title, | |
2736 bool by_user) { | |
2737 delegate_->SimulateWebNotificationClose(title, by_user); | |
2738 } | |
2739 | |
2740 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript, | |
2741 double confidence) { | |
2742 getMockWebSpeechRecognizer()->AddMockResult(WebString::fromUTF8(transcript), | |
2743 confidence); | |
2744 } | |
2745 | |
2746 void TestRunner::SetMockSpeechRecognitionError(const std::string& error, | |
2747 const std::string& message) { | |
2748 getMockWebSpeechRecognizer()->SetError(WebString::fromUTF8(error), | |
2749 WebString::fromUTF8(message)); | |
2750 } | |
2751 | |
2752 void TestRunner::SetMockCredentialManagerResponse(const std::string& id, | |
2753 const std::string& name, | |
2754 const std::string& avatar, | |
2755 const std::string& password) { | |
2756 credential_manager_client_->SetResponse(new WebPasswordCredential( | |
2757 WebString::fromUTF8(id), WebString::fromUTF8(password), | |
2758 WebString::fromUTF8(name), WebURL(GURL(avatar)))); | |
2759 } | |
2760 | |
2761 void TestRunner::ClearMockCredentialManagerResponse() { | |
2762 credential_manager_client_->SetResponse(nullptr); | |
2763 } | |
2764 | |
2765 void TestRunner::SetMockCredentialManagerError(const std::string& error) { | |
2766 credential_manager_client_->SetError(error); | |
2767 } | |
2768 | |
2769 void TestRunner::OnLayoutTestRuntimeFlagsChanged() { | |
2770 if (layout_test_runtime_flags_.tracked_dictionary().changed_values().empty()) | |
2771 return; | |
2772 if (!test_is_running_) | |
2773 return; | |
2774 | |
2775 delegate_->OnLayoutTestRuntimeFlagsChanged( | |
2776 layout_test_runtime_flags_.tracked_dictionary().changed_values()); | |
2777 layout_test_runtime_flags_.tracked_dictionary().ResetChangeTracking(); | |
2778 } | |
2779 | |
2780 void TestRunner::LocationChangeDone() { | |
2781 web_history_item_count_ = delegate_->NavigationEntryCount(); | |
2782 | |
2783 // No more new work after the first complete load. | |
2784 work_queue_.set_frozen(true); | |
2785 | |
2786 if (!layout_test_runtime_flags_.wait_until_done()) | |
2787 work_queue_.ProcessWorkSoon(); | |
2788 } | |
2789 | |
2790 void TestRunner::CheckResponseMimeType() { | |
2791 // Text output: the test page can request different types of output which we | |
2792 // handle here. | |
2793 | |
2794 if (layout_test_runtime_flags_.dump_as_text()) | |
2795 return; | |
2796 | |
2797 if (!main_view_) | |
2798 return; | |
2799 | |
2800 WebDataSource* data_source = main_view_->mainFrame()->dataSource(); | |
2801 if (!data_source) | |
2802 return; | |
2803 | |
2804 std::string mimeType = data_source->response().mimeType().utf8(); | |
2805 if (mimeType != "text/plain") | |
2806 return; | |
2807 | |
2808 layout_test_runtime_flags_.set_dump_as_text(true); | |
2809 layout_test_runtime_flags_.set_generate_pixel_results(false); | |
2810 OnLayoutTestRuntimeFlagsChanged(); | |
2811 } | |
2812 | |
2813 void TestRunner::NotifyDone() { | |
2814 if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() && | |
2815 !will_navigate_ && work_queue_.is_empty()) | |
2816 delegate_->TestFinished(); | |
2817 layout_test_runtime_flags_.set_wait_until_done(false); | |
2818 OnLayoutTestRuntimeFlagsChanged(); | |
2819 } | |
2820 | |
2821 } // namespace test_runner | |
OLD | NEW |