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 "content/shell/renderer/test_runner/test_runner.h"
6
7 #include <limits>
8
9 #include "base/logging.h"
10 #include "content/shell/common/test_runner/test_preferences.h"
11 #include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
12 #include "content/shell/renderer/test_runner/TestInterfaces.h"
13 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
14 #include "content/shell/renderer/test_runner/mock_web_push_client.h"
15 #include "content/shell/renderer/test_runner/notification_presenter.h"
16 #include "content/shell/renderer/test_runner/web_permissions.h"
17 #include "content/shell/renderer/test_runner/web_test_proxy.h"
18 #include "gin/arguments.h"
19 #include "gin/array_buffer.h"
20 #include "gin/handle.h"
21 #include "gin/object_template_builder.h"
22 #include "gin/wrappable.h"
23 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
24 #include "third_party/WebKit/public/platform/WebBatteryStatus.h"
25 #include "third_party/WebKit/public/platform/WebCanvas.h"
26 #include "third_party/WebKit/public/platform/WebData.h"
27 #include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
28 #include "third_party/WebKit/public/platform/WebDeviceOrientationData.h"
29 #include "third_party/WebKit/public/platform/WebPoint.h"
30 #include "third_party/WebKit/public/platform/WebURLResponse.h"
31 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
32 #include "third_party/WebKit/public/web/WebBindings.h"
33 #include "third_party/WebKit/public/web/WebDataSource.h"
34 #include "third_party/WebKit/public/web/WebDocument.h"
35 #include "third_party/WebKit/public/web/WebFindOptions.h"
36 #include "third_party/WebKit/public/web/WebFrame.h"
37 #include "third_party/WebKit/public/web/WebInputElement.h"
38 #include "third_party/WebKit/public/web/WebKit.h"
39 #include "third_party/WebKit/public/web/WebMIDIClientMock.h"
40 #include "third_party/WebKit/public/web/WebPageOverlay.h"
41 #include "third_party/WebKit/public/web/WebScriptSource.h"
42 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
43 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
44 #include "third_party/WebKit/public/web/WebSettings.h"
45 #include "third_party/WebKit/public/web/WebSurroundingText.h"
46 #include "third_party/WebKit/public/web/WebView.h"
47 #include "third_party/skia/include/core/SkBitmap.h"
48 #include "third_party/skia/include/core/SkCanvas.h"
49
50 #if defined(__linux__) || defined(ANDROID)
51 #include "third_party/WebKit/public/web/linux/WebFontRendering.h"
52 #endif
53
54 using namespace blink;
55
56 namespace content {
57
58 namespace {
59
V8StringToWebString(v8::Handle<v8::String> v8_str)60 WebString V8StringToWebString(v8::Handle<v8::String> v8_str) {
61 int length = v8_str->Utf8Length() + 1;
62 scoped_ptr<char[]> chars(new char[length]);
63 v8_str->WriteUtf8(chars.get(), length);
64 return WebString::fromUTF8(chars.get());
65 }
66
67 class HostMethodTask : public WebMethodTask<TestRunner> {
68 public:
69 typedef void (TestRunner::*CallbackMethodType)();
HostMethodTask(TestRunner * object,CallbackMethodType callback)70 HostMethodTask(TestRunner* object, CallbackMethodType callback)
71 : WebMethodTask<TestRunner>(object), callback_(callback) {}
72
runIfValid()73 virtual void runIfValid() OVERRIDE {
74 (m_object->*callback_)();
75 }
76
77 private:
78 CallbackMethodType callback_;
79 };
80
81 } // namespace
82
83 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
84 public:
InvokeCallbackTask(TestRunner * object,v8::Handle<v8::Function> callback)85 InvokeCallbackTask(TestRunner* object, v8::Handle<v8::Function> callback)
86 : WebMethodTask<TestRunner>(object),
87 callback_(blink::mainThreadIsolate(), callback),
88 argc_(0) {}
89
runIfValid()90 virtual void runIfValid() OVERRIDE {
91 v8::Isolate* isolate = blink::mainThreadIsolate();
92 v8::HandleScope handle_scope(isolate);
93 WebFrame* frame = m_object->web_view_->mainFrame();
94
95 v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
96 if (context.IsEmpty())
97 return;
98
99 v8::Context::Scope context_scope(context);
100
101 scoped_ptr<v8::Handle<v8::Value>[]> local_argv;
102 if (argc_) {
103 local_argv.reset(new v8::Handle<v8::Value>[argc_]);
104 for (int i = 0; i < argc_; ++i)
105 local_argv[i] = v8::Local<v8::Value>::New(isolate, argv_[i]);
106 }
107
108 frame->callFunctionEvenIfScriptDisabled(
109 v8::Local<v8::Function>::New(isolate, callback_),
110 context->Global(),
111 argc_,
112 local_argv.get());
113 }
114
SetArguments(int argc,v8::Handle<v8::Value> argv[])115 void SetArguments(int argc, v8::Handle<v8::Value> argv[]) {
116 v8::Isolate* isolate = blink::mainThreadIsolate();
117 argc_ = argc;
118 argv_.reset(new v8::UniquePersistent<v8::Value>[argc]);
119 for (int i = 0; i < argc; ++i)
120 argv_[i] = v8::UniquePersistent<v8::Value>(isolate, argv[i]);
121 }
122
123 private:
124 v8::UniquePersistent<v8::Function> callback_;
125 int argc_;
126 scoped_ptr<v8::UniquePersistent<v8::Value>[]> argv_;
127 };
128
129 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
130 public:
131 static gin::WrapperInfo kWrapperInfo;
132
133 static void Install(base::WeakPtr<TestRunner> controller,
134 WebFrame* frame);
135
136 private:
137 explicit TestRunnerBindings(
138 base::WeakPtr<TestRunner> controller);
139 virtual ~TestRunnerBindings();
140
141 // gin::Wrappable:
142 virtual gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
143 v8::Isolate* isolate) OVERRIDE;
144
145 void LogToStderr(const std::string& output);
146 void NotifyDone();
147 void WaitUntilDone();
148 void QueueBackNavigation(int how_far_back);
149 void QueueForwardNavigation(int how_far_forward);
150 void QueueReload();
151 void QueueLoadingScript(const std::string& script);
152 void QueueNonLoadingScript(const std::string& script);
153 void QueueLoad(gin::Arguments* args);
154 void QueueLoadHTMLString(gin::Arguments* args);
155 void SetCustomPolicyDelegate(gin::Arguments* args);
156 void WaitForPolicyDelegate();
157 int WindowCount();
158 void SetCloseRemainingWindowsWhenComplete(gin::Arguments* args);
159 void ResetTestHelperControllers();
160 void SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements);
161 void ExecCommand(gin::Arguments* args);
162 bool IsCommandEnabled(const std::string& command);
163 bool CallShouldCloseOnWebView();
164 void SetDomainRelaxationForbiddenForURLScheme(bool forbidden,
165 const std::string& scheme);
166 v8::Handle<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue(
167 int world_id, const std::string& script);
168 void EvaluateScriptInIsolatedWorld(int world_id, const std::string& script);
169 void SetIsolatedWorldSecurityOrigin(int world_id,
170 v8::Handle<v8::Value> origin);
171 void SetIsolatedWorldContentSecurityPolicy(int world_id,
172 const std::string& policy);
173 void AddOriginAccessWhitelistEntry(const std::string& source_origin,
174 const std::string& destination_protocol,
175 const std::string& destination_host,
176 bool allow_destination_subdomains);
177 void RemoveOriginAccessWhitelistEntry(const std::string& source_origin,
178 const std::string& destination_protocol,
179 const std::string& destination_host,
180 bool allow_destination_subdomains);
181 bool HasCustomPageSizeStyle(int page_index);
182 void ForceRedSelectionColors();
183 void InjectStyleSheet(const std::string& source_code, bool all_frames);
184 bool FindString(const std::string& search_text,
185 const std::vector<std::string>& options_array);
186 std::string SelectionAsMarkup();
187 void SetTextSubpixelPositioning(bool value);
188 void SetPageVisibility(const std::string& new_visibility);
189 void SetTextDirection(const std::string& direction_name);
190 void UseUnfortunateSynchronousResizeMode();
191 bool EnableAutoResizeMode(int min_width,
192 int min_height,
193 int max_width,
194 int max_height);
195 bool DisableAutoResizeMode(int new_width, int new_height);
196 void SetMockDeviceMotion(gin::Arguments* args);
197 void SetMockDeviceOrientation(gin::Arguments* args);
198 void SetMockScreenOrientation(const std::string& orientation);
199 void DidChangeBatteryStatus(bool charging,
200 double chargingTime,
201 double dischargingTime,
202 double level);
203 void ResetBatteryStatus();
204 void DidAcquirePointerLock();
205 void DidNotAcquirePointerLock();
206 void DidLosePointerLock();
207 void SetPointerLockWillFailSynchronously();
208 void SetPointerLockWillRespondAsynchronously();
209 void SetPopupBlockingEnabled(bool block_popups);
210 void SetJavaScriptCanAccessClipboard(bool can_access);
211 void SetXSSAuditorEnabled(bool enabled);
212 void SetAllowUniversalAccessFromFileURLs(bool allow);
213 void SetAllowFileAccessFromFileURLs(bool allow);
214 void OverridePreference(const std::string key, v8::Handle<v8::Value> value);
215 void SetAcceptLanguages(const std::string& accept_languages);
216 void SetPluginsEnabled(bool enabled);
217 void DumpEditingCallbacks();
218 void DumpAsMarkup();
219 void DumpAsText();
220 void DumpAsTextWithPixelResults();
221 void DumpChildFrameScrollPositions();
222 void DumpChildFramesAsMarkup();
223 void DumpChildFramesAsText();
224 void DumpIconChanges();
225 void SetAudioData(const gin::ArrayBufferView& view);
226 void DumpFrameLoadCallbacks();
227 void DumpPingLoaderCallbacks();
228 void DumpUserGestureInFrameLoadCallbacks();
229 void DumpTitleChanges();
230 void DumpCreateView();
231 void SetCanOpenWindows();
232 void DumpResourceLoadCallbacks();
233 void DumpResourceRequestCallbacks();
234 void DumpResourceResponseMIMETypes();
235 void SetImagesAllowed(bool allowed);
236 void SetMediaAllowed(bool allowed);
237 void SetScriptsAllowed(bool allowed);
238 void SetStorageAllowed(bool allowed);
239 void SetPluginsAllowed(bool allowed);
240 void SetAllowDisplayOfInsecureContent(bool allowed);
241 void SetAllowRunningOfInsecureContent(bool allowed);
242 void DumpPermissionClientCallbacks();
243 void DumpWindowStatusChanges();
244 void DumpProgressFinishedCallback();
245 void DumpSpellCheckCallbacks();
246 void DumpBackForwardList();
247 void DumpSelectionRect();
248 void SetPrinting();
249 void SetShouldStayOnPageAfterHandlingBeforeUnload(bool value);
250 void SetWillSendRequestClearHeader(const std::string& header);
251 void DumpResourceRequestPriorities();
252 void SetUseMockTheme(bool use);
253 void WaitUntilExternalURLLoad();
254 void ShowWebInspector(gin::Arguments* args);
255 void CloseWebInspector();
256 bool IsChooserShown();
257 void EvaluateInWebInspector(int call_id, const std::string& script);
258 void ClearAllDatabases();
259 void SetDatabaseQuota(int quota);
260 void SetAlwaysAcceptCookies(bool accept);
261 void SetWindowIsKey(bool value);
262 std::string PathToLocalResource(const std::string& path);
263 void SetBackingScaleFactor(double value, v8::Handle<v8::Function> callback);
264 void SetColorProfile(const std::string& name,
265 v8::Handle<v8::Function> callback);
266 void SetPOSIXLocale(const std::string& locale);
267 void SetMIDIAccessorResult(bool result);
268 void SetMIDISysexPermission(bool value);
269 void GrantWebNotificationPermission(gin::Arguments* args);
270 bool SimulateWebNotificationClick(const std::string& value);
271 void AddMockSpeechRecognitionResult(const std::string& transcript,
272 double confidence);
273 void SetMockSpeechRecognitionError(const std::string& error,
274 const std::string& message);
275 bool WasMockSpeechRecognitionAborted();
276 void AddWebPageOverlay();
277 void RemoveWebPageOverlay();
278 void DisplayAsync();
279 void DisplayAsyncThen(v8::Handle<v8::Function> callback);
280 void CapturePixelsAsyncThen(v8::Handle<v8::Function> callback);
281 void SetCustomTextOutput(std::string output);
282 void SetViewSourceForFrame(const std::string& name, bool enabled);
283 void setMockPushClientSuccess(const std::string& end_point,
284 const std::string& registration_id);
285 void setMockPushClientError(const std::string& message);
286
287 bool GlobalFlag();
288 void SetGlobalFlag(bool value);
289 std::string PlatformName();
290 std::string TooltipText();
291 bool DisableNotifyDone();
292 int WebHistoryItemCount();
293 bool InterceptPostMessage();
294 void SetInterceptPostMessage(bool value);
295
296 void NotImplemented(const gin::Arguments& args);
297
298 base::WeakPtr<TestRunner> runner_;
299
300 DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings);
301 };
302
303 gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {
304 gin::kEmbedderNativeGin};
305
306 // static
Install(base::WeakPtr<TestRunner> runner,WebFrame * frame)307 void TestRunnerBindings::Install(base::WeakPtr<TestRunner> runner,
308 WebFrame* frame) {
309 v8::Isolate* isolate = blink::mainThreadIsolate();
310 v8::HandleScope handle_scope(isolate);
311 v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
312 if (context.IsEmpty())
313 return;
314
315 v8::Context::Scope context_scope(context);
316
317 gin::Handle<TestRunnerBindings> bindings =
318 gin::CreateHandle(isolate, new TestRunnerBindings(runner));
319 if (bindings.IsEmpty())
320 return;
321 v8::Handle<v8::Object> global = context->Global();
322 v8::Handle<v8::Value> v8_bindings = bindings.ToV8();
323 global->Set(gin::StringToV8(isolate, "testRunner"), v8_bindings);
324 global->Set(gin::StringToV8(isolate, "layoutTestController"), v8_bindings);
325 }
326
TestRunnerBindings(base::WeakPtr<TestRunner> runner)327 TestRunnerBindings::TestRunnerBindings(base::WeakPtr<TestRunner> runner)
328 : runner_(runner) {}
329
~TestRunnerBindings()330 TestRunnerBindings::~TestRunnerBindings() {}
331
GetObjectTemplateBuilder(v8::Isolate * isolate)332 gin::ObjectTemplateBuilder TestRunnerBindings::GetObjectTemplateBuilder(
333 v8::Isolate* isolate) {
334 return gin::Wrappable<TestRunnerBindings>::GetObjectTemplateBuilder(isolate)
335 // Methods controlling test execution.
336 .SetMethod("logToStderr", &TestRunnerBindings::LogToStderr)
337 .SetMethod("notifyDone", &TestRunnerBindings::NotifyDone)
338 .SetMethod("waitUntilDone", &TestRunnerBindings::WaitUntilDone)
339 .SetMethod("queueBackNavigation",
340 &TestRunnerBindings::QueueBackNavigation)
341 .SetMethod("queueForwardNavigation",
342 &TestRunnerBindings::QueueForwardNavigation)
343 .SetMethod("queueReload", &TestRunnerBindings::QueueReload)
344 .SetMethod("queueLoadingScript", &TestRunnerBindings::QueueLoadingScript)
345 .SetMethod("queueNonLoadingScript",
346 &TestRunnerBindings::QueueNonLoadingScript)
347 .SetMethod("queueLoad", &TestRunnerBindings::QueueLoad)
348 .SetMethod("queueLoadHTMLString",
349 &TestRunnerBindings::QueueLoadHTMLString)
350 .SetMethod("setCustomPolicyDelegate",
351 &TestRunnerBindings::SetCustomPolicyDelegate)
352 .SetMethod("waitForPolicyDelegate",
353 &TestRunnerBindings::WaitForPolicyDelegate)
354 .SetMethod("windowCount", &TestRunnerBindings::WindowCount)
355 .SetMethod("setCloseRemainingWindowsWhenComplete",
356 &TestRunnerBindings::SetCloseRemainingWindowsWhenComplete)
357 .SetMethod("resetTestHelperControllers",
358 &TestRunnerBindings::ResetTestHelperControllers)
359 .SetMethod("setTabKeyCyclesThroughElements",
360 &TestRunnerBindings::SetTabKeyCyclesThroughElements)
361 .SetMethod("execCommand", &TestRunnerBindings::ExecCommand)
362 .SetMethod("isCommandEnabled", &TestRunnerBindings::IsCommandEnabled)
363 .SetMethod("callShouldCloseOnWebView",
364 &TestRunnerBindings::CallShouldCloseOnWebView)
365 .SetMethod("setDomainRelaxationForbiddenForURLScheme",
366 &TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme)
367 .SetMethod(
368 "evaluateScriptInIsolatedWorldAndReturnValue",
369 &TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue)
370 .SetMethod("evaluateScriptInIsolatedWorld",
371 &TestRunnerBindings::EvaluateScriptInIsolatedWorld)
372 .SetMethod("setIsolatedWorldSecurityOrigin",
373 &TestRunnerBindings::SetIsolatedWorldSecurityOrigin)
374 .SetMethod("setIsolatedWorldContentSecurityPolicy",
375 &TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy)
376 .SetMethod("addOriginAccessWhitelistEntry",
377 &TestRunnerBindings::AddOriginAccessWhitelistEntry)
378 .SetMethod("removeOriginAccessWhitelistEntry",
379 &TestRunnerBindings::RemoveOriginAccessWhitelistEntry)
380 .SetMethod("hasCustomPageSizeStyle",
381 &TestRunnerBindings::HasCustomPageSizeStyle)
382 .SetMethod("forceRedSelectionColors",
383 &TestRunnerBindings::ForceRedSelectionColors)
384 .SetMethod("injectStyleSheet", &TestRunnerBindings::InjectStyleSheet)
385 .SetMethod("findString", &TestRunnerBindings::FindString)
386 .SetMethod("selectionAsMarkup", &TestRunnerBindings::SelectionAsMarkup)
387 .SetMethod("setTextSubpixelPositioning",
388 &TestRunnerBindings::SetTextSubpixelPositioning)
389 .SetMethod("setPageVisibility", &TestRunnerBindings::SetPageVisibility)
390 .SetMethod("setTextDirection", &TestRunnerBindings::SetTextDirection)
391 .SetMethod("useUnfortunateSynchronousResizeMode",
392 &TestRunnerBindings::UseUnfortunateSynchronousResizeMode)
393 .SetMethod("enableAutoResizeMode",
394 &TestRunnerBindings::EnableAutoResizeMode)
395 .SetMethod("disableAutoResizeMode",
396 &TestRunnerBindings::DisableAutoResizeMode)
397 .SetMethod("setMockDeviceMotion",
398 &TestRunnerBindings::SetMockDeviceMotion)
399 .SetMethod("setMockDeviceOrientation",
400 &TestRunnerBindings::SetMockDeviceOrientation)
401 .SetMethod("setMockScreenOrientation",
402 &TestRunnerBindings::SetMockScreenOrientation)
403 .SetMethod("didChangeBatteryStatus",
404 &TestRunnerBindings::DidChangeBatteryStatus)
405 .SetMethod("resetBatteryStatus",
406 &TestRunnerBindings::ResetBatteryStatus)
407 .SetMethod("didAcquirePointerLock",
408 &TestRunnerBindings::DidAcquirePointerLock)
409 .SetMethod("didNotAcquirePointerLock",
410 &TestRunnerBindings::DidNotAcquirePointerLock)
411 .SetMethod("didLosePointerLock", &TestRunnerBindings::DidLosePointerLock)
412 .SetMethod("setPointerLockWillFailSynchronously",
413 &TestRunnerBindings::SetPointerLockWillFailSynchronously)
414 .SetMethod("setPointerLockWillRespondAsynchronously",
415 &TestRunnerBindings::SetPointerLockWillRespondAsynchronously)
416 .SetMethod("setPopupBlockingEnabled",
417 &TestRunnerBindings::SetPopupBlockingEnabled)
418 .SetMethod("setJavaScriptCanAccessClipboard",
419 &TestRunnerBindings::SetJavaScriptCanAccessClipboard)
420 .SetMethod("setXSSAuditorEnabled",
421 &TestRunnerBindings::SetXSSAuditorEnabled)
422 .SetMethod("setAllowUniversalAccessFromFileURLs",
423 &TestRunnerBindings::SetAllowUniversalAccessFromFileURLs)
424 .SetMethod("setAllowFileAccessFromFileURLs",
425 &TestRunnerBindings::SetAllowFileAccessFromFileURLs)
426 .SetMethod("overridePreference", &TestRunnerBindings::OverridePreference)
427 .SetMethod("setAcceptLanguages", &TestRunnerBindings::SetAcceptLanguages)
428 .SetMethod("setPluginsEnabled", &TestRunnerBindings::SetPluginsEnabled)
429 .SetMethod("dumpEditingCallbacks",
430 &TestRunnerBindings::DumpEditingCallbacks)
431 .SetMethod("dumpAsMarkup", &TestRunnerBindings::DumpAsMarkup)
432 .SetMethod("dumpAsText", &TestRunnerBindings::DumpAsText)
433 .SetMethod("dumpAsTextWithPixelResults",
434 &TestRunnerBindings::DumpAsTextWithPixelResults)
435 .SetMethod("dumpChildFrameScrollPositions",
436 &TestRunnerBindings::DumpChildFrameScrollPositions)
437 .SetMethod("dumpChildFramesAsText",
438 &TestRunnerBindings::DumpChildFramesAsText)
439 .SetMethod("dumpChildFramesAsMarkup",
440 &TestRunnerBindings::DumpChildFramesAsMarkup)
441 .SetMethod("dumpIconChanges", &TestRunnerBindings::DumpIconChanges)
442 .SetMethod("setAudioData", &TestRunnerBindings::SetAudioData)
443 .SetMethod("dumpFrameLoadCallbacks",
444 &TestRunnerBindings::DumpFrameLoadCallbacks)
445 .SetMethod("dumpPingLoaderCallbacks",
446 &TestRunnerBindings::DumpPingLoaderCallbacks)
447 .SetMethod("dumpUserGestureInFrameLoadCallbacks",
448 &TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks)
449 .SetMethod("dumpTitleChanges", &TestRunnerBindings::DumpTitleChanges)
450 .SetMethod("dumpCreateView", &TestRunnerBindings::DumpCreateView)
451 .SetMethod("setCanOpenWindows", &TestRunnerBindings::SetCanOpenWindows)
452 .SetMethod("dumpResourceLoadCallbacks",
453 &TestRunnerBindings::DumpResourceLoadCallbacks)
454 .SetMethod("dumpResourceRequestCallbacks",
455 &TestRunnerBindings::DumpResourceRequestCallbacks)
456 .SetMethod("dumpResourceResponseMIMETypes",
457 &TestRunnerBindings::DumpResourceResponseMIMETypes)
458 .SetMethod("setImagesAllowed", &TestRunnerBindings::SetImagesAllowed)
459 .SetMethod("setMediaAllowed", &TestRunnerBindings::SetMediaAllowed)
460 .SetMethod("setScriptsAllowed", &TestRunnerBindings::SetScriptsAllowed)
461 .SetMethod("setStorageAllowed", &TestRunnerBindings::SetStorageAllowed)
462 .SetMethod("setPluginsAllowed", &TestRunnerBindings::SetPluginsAllowed)
463 .SetMethod("setAllowDisplayOfInsecureContent",
464 &TestRunnerBindings::SetAllowDisplayOfInsecureContent)
465 .SetMethod("setAllowRunningOfInsecureContent",
466 &TestRunnerBindings::SetAllowRunningOfInsecureContent)
467 .SetMethod("dumpPermissionClientCallbacks",
468 &TestRunnerBindings::DumpPermissionClientCallbacks)
469 .SetMethod("dumpWindowStatusChanges",
470 &TestRunnerBindings::DumpWindowStatusChanges)
471 .SetMethod("dumpProgressFinishedCallback",
472 &TestRunnerBindings::DumpProgressFinishedCallback)
473 .SetMethod("dumpSpellCheckCallbacks",
474 &TestRunnerBindings::DumpSpellCheckCallbacks)
475 .SetMethod("dumpBackForwardList",
476 &TestRunnerBindings::DumpBackForwardList)
477 .SetMethod("dumpSelectionRect", &TestRunnerBindings::DumpSelectionRect)
478 .SetMethod("setPrinting", &TestRunnerBindings::SetPrinting)
479 .SetMethod(
480 "setShouldStayOnPageAfterHandlingBeforeUnload",
481 &TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload)
482 .SetMethod("setWillSendRequestClearHeader",
483 &TestRunnerBindings::SetWillSendRequestClearHeader)
484 .SetMethod("dumpResourceRequestPriorities",
485 &TestRunnerBindings::DumpResourceRequestPriorities)
486 .SetMethod("setUseMockTheme", &TestRunnerBindings::SetUseMockTheme)
487 .SetMethod("waitUntilExternalURLLoad",
488 &TestRunnerBindings::WaitUntilExternalURLLoad)
489 .SetMethod("showWebInspector", &TestRunnerBindings::ShowWebInspector)
490 .SetMethod("closeWebInspector", &TestRunnerBindings::CloseWebInspector)
491 .SetMethod("isChooserShown", &TestRunnerBindings::IsChooserShown)
492 .SetMethod("evaluateInWebInspector",
493 &TestRunnerBindings::EvaluateInWebInspector)
494 .SetMethod("clearAllDatabases", &TestRunnerBindings::ClearAllDatabases)
495 .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota)
496 .SetMethod("setAlwaysAcceptCookies",
497 &TestRunnerBindings::SetAlwaysAcceptCookies)
498 .SetMethod("setWindowIsKey", &TestRunnerBindings::SetWindowIsKey)
499 .SetMethod("pathToLocalResource",
500 &TestRunnerBindings::PathToLocalResource)
501 .SetMethod("setBackingScaleFactor",
502 &TestRunnerBindings::SetBackingScaleFactor)
503 .SetMethod("setColorProfile",
504 &TestRunnerBindings::SetColorProfile)
505 .SetMethod("setPOSIXLocale", &TestRunnerBindings::SetPOSIXLocale)
506 .SetMethod("setMIDIAccessorResult",
507 &TestRunnerBindings::SetMIDIAccessorResult)
508 .SetMethod("setMIDISysexPermission",
509 &TestRunnerBindings::SetMIDISysexPermission)
510 .SetMethod("grantWebNotificationPermission",
511 &TestRunnerBindings::GrantWebNotificationPermission)
512 .SetMethod("simulateWebNotificationClick",
513 &TestRunnerBindings::SimulateWebNotificationClick)
514 .SetMethod("addMockSpeechRecognitionResult",
515 &TestRunnerBindings::AddMockSpeechRecognitionResult)
516 .SetMethod("setMockSpeechRecognitionError",
517 &TestRunnerBindings::SetMockSpeechRecognitionError)
518 .SetMethod("wasMockSpeechRecognitionAborted",
519 &TestRunnerBindings::WasMockSpeechRecognitionAborted)
520 .SetMethod("addWebPageOverlay", &TestRunnerBindings::AddWebPageOverlay)
521 .SetMethod("removeWebPageOverlay",
522 &TestRunnerBindings::RemoveWebPageOverlay)
523 .SetMethod("displayAsync", &TestRunnerBindings::DisplayAsync)
524 .SetMethod("displayAsyncThen", &TestRunnerBindings::DisplayAsyncThen)
525 .SetMethod("capturePixelsAsyncThen", &TestRunnerBindings::CapturePixelsAsyncThen)
526 .SetMethod("setCustomTextOutput",
527 &TestRunnerBindings::SetCustomTextOutput)
528 .SetMethod("setViewSourceForFrame",
529 &TestRunnerBindings::SetViewSourceForFrame)
530 .SetMethod("setMockPushClientSuccess",
531 &TestRunnerBindings::setMockPushClientSuccess)
532 .SetMethod("setMockPushClientError",
533 &TestRunnerBindings::setMockPushClientError)
534
535 // Properties.
536 .SetProperty("globalFlag",
537 &TestRunnerBindings::GlobalFlag,
538 &TestRunnerBindings::SetGlobalFlag)
539 .SetProperty("platformName", &TestRunnerBindings::PlatformName)
540 .SetProperty("tooltipText", &TestRunnerBindings::TooltipText)
541 .SetProperty("disableNotifyDone", &TestRunnerBindings::DisableNotifyDone)
542 // webHistoryItemCount is used by tests in LayoutTests\http\tests\history
543 .SetProperty("webHistoryItemCount",
544 &TestRunnerBindings::WebHistoryItemCount)
545 .SetProperty("interceptPostMessage",
546 &TestRunnerBindings::InterceptPostMessage,
547 &TestRunnerBindings::SetInterceptPostMessage)
548
549 // The following are stubs.
550 .SetMethod("dumpDatabaseCallbacks", &TestRunnerBindings::NotImplemented)
551 .SetMethod("setIconDatabaseEnabled", &TestRunnerBindings::NotImplemented)
552 .SetMethod("setScrollbarPolicy", &TestRunnerBindings::NotImplemented)
553 .SetMethod("clearAllApplicationCaches",
554 &TestRunnerBindings::NotImplemented)
555 .SetMethod("clearApplicationCacheForOrigin",
556 &TestRunnerBindings::NotImplemented)
557 .SetMethod("clearBackForwardList", &TestRunnerBindings::NotImplemented)
558 .SetMethod("keepWebHistory", &TestRunnerBindings::NotImplemented)
559 .SetMethod("setApplicationCacheOriginQuota",
560 &TestRunnerBindings::NotImplemented)
561 .SetMethod("setCallCloseOnWebViews", &TestRunnerBindings::NotImplemented)
562 .SetMethod("setMainFrameIsFirstResponder",
563 &TestRunnerBindings::NotImplemented)
564 .SetMethod("setUseDashboardCompatibilityMode",
565 &TestRunnerBindings::NotImplemented)
566 .SetMethod("deleteAllLocalStorage", &TestRunnerBindings::NotImplemented)
567 .SetMethod("localStorageDiskUsageForOrigin",
568 &TestRunnerBindings::NotImplemented)
569 .SetMethod("originsWithLocalStorage", &TestRunnerBindings::NotImplemented)
570 .SetMethod("deleteLocalStorageForOrigin",
571 &TestRunnerBindings::NotImplemented)
572 .SetMethod("observeStorageTrackerNotifications",
573 &TestRunnerBindings::NotImplemented)
574 .SetMethod("syncLocalStorage", &TestRunnerBindings::NotImplemented)
575 .SetMethod("addDisallowedURL", &TestRunnerBindings::NotImplemented)
576 .SetMethod("applicationCacheDiskUsageForOrigin",
577 &TestRunnerBindings::NotImplemented)
578 .SetMethod("abortModal", &TestRunnerBindings::NotImplemented)
579
580 // Aliases.
581 // Used at fast/dom/assign-to-window-status.html
582 .SetMethod("dumpStatusCallbacks",
583 &TestRunnerBindings::DumpWindowStatusChanges);
584 }
585
LogToStderr(const std::string & output)586 void TestRunnerBindings::LogToStderr(const std::string& output) {
587 LOG(ERROR) << output;
588 }
589
NotifyDone()590 void TestRunnerBindings::NotifyDone() {
591 if (runner_)
592 runner_->NotifyDone();
593 }
594
WaitUntilDone()595 void TestRunnerBindings::WaitUntilDone() {
596 if (runner_)
597 runner_->WaitUntilDone();
598 }
599
QueueBackNavigation(int how_far_back)600 void TestRunnerBindings::QueueBackNavigation(int how_far_back) {
601 if (runner_)
602 runner_->QueueBackNavigation(how_far_back);
603 }
604
QueueForwardNavigation(int how_far_forward)605 void TestRunnerBindings::QueueForwardNavigation(int how_far_forward) {
606 if (runner_)
607 runner_->QueueForwardNavigation(how_far_forward);
608 }
609
QueueReload()610 void TestRunnerBindings::QueueReload() {
611 if (runner_)
612 runner_->QueueReload();
613 }
614
QueueLoadingScript(const std::string & script)615 void TestRunnerBindings::QueueLoadingScript(const std::string& script) {
616 if (runner_)
617 runner_->QueueLoadingScript(script);
618 }
619
QueueNonLoadingScript(const std::string & script)620 void TestRunnerBindings::QueueNonLoadingScript(const std::string& script) {
621 if (runner_)
622 runner_->QueueNonLoadingScript(script);
623 }
624
QueueLoad(gin::Arguments * args)625 void TestRunnerBindings::QueueLoad(gin::Arguments* args) {
626 if (runner_) {
627 std::string url;
628 std::string target;
629 args->GetNext(&url);
630 args->GetNext(&target);
631 runner_->QueueLoad(url, target);
632 }
633 }
634
QueueLoadHTMLString(gin::Arguments * args)635 void TestRunnerBindings::QueueLoadHTMLString(gin::Arguments* args) {
636 if (runner_)
637 runner_->QueueLoadHTMLString(args);
638 }
639
SetCustomPolicyDelegate(gin::Arguments * args)640 void TestRunnerBindings::SetCustomPolicyDelegate(gin::Arguments* args) {
641 if (runner_)
642 runner_->SetCustomPolicyDelegate(args);
643 }
644
WaitForPolicyDelegate()645 void TestRunnerBindings::WaitForPolicyDelegate() {
646 if (runner_)
647 runner_->WaitForPolicyDelegate();
648 }
649
WindowCount()650 int TestRunnerBindings::WindowCount() {
651 if (runner_)
652 return runner_->WindowCount();
653 return 0;
654 }
655
SetCloseRemainingWindowsWhenComplete(gin::Arguments * args)656 void TestRunnerBindings::SetCloseRemainingWindowsWhenComplete(
657 gin::Arguments* args) {
658 if (!runner_)
659 return;
660
661 // In the original implementation, nothing happens if the argument is
662 // ommitted.
663 bool close_remaining_windows = false;
664 if (args->GetNext(&close_remaining_windows))
665 runner_->SetCloseRemainingWindowsWhenComplete(close_remaining_windows);
666 }
667
ResetTestHelperControllers()668 void TestRunnerBindings::ResetTestHelperControllers() {
669 if (runner_)
670 runner_->ResetTestHelperControllers();
671 }
672
SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements)673 void TestRunnerBindings::SetTabKeyCyclesThroughElements(
674 bool tab_key_cycles_through_elements) {
675 if (runner_)
676 runner_->SetTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
677 }
678
ExecCommand(gin::Arguments * args)679 void TestRunnerBindings::ExecCommand(gin::Arguments* args) {
680 if (runner_)
681 runner_->ExecCommand(args);
682 }
683
IsCommandEnabled(const std::string & command)684 bool TestRunnerBindings::IsCommandEnabled(const std::string& command) {
685 if (runner_)
686 return runner_->IsCommandEnabled(command);
687 return false;
688 }
689
CallShouldCloseOnWebView()690 bool TestRunnerBindings::CallShouldCloseOnWebView() {
691 if (runner_)
692 return runner_->CallShouldCloseOnWebView();
693 return false;
694 }
695
SetDomainRelaxationForbiddenForURLScheme(bool forbidden,const std::string & scheme)696 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme(
697 bool forbidden, const std::string& scheme) {
698 if (runner_)
699 runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
700 }
701
702 v8::Handle<v8::Value>
EvaluateScriptInIsolatedWorldAndReturnValue(int world_id,const std::string & script)703 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
704 int world_id, const std::string& script) {
705 if (!runner_)
706 return v8::Handle<v8::Value>();
707 return runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
708 script);
709 }
710
EvaluateScriptInIsolatedWorld(int world_id,const std::string & script)711 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
712 int world_id, const std::string& script) {
713 if (runner_)
714 runner_->EvaluateScriptInIsolatedWorld(world_id, script);
715 }
716
SetIsolatedWorldSecurityOrigin(int world_id,v8::Handle<v8::Value> origin)717 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin(
718 int world_id, v8::Handle<v8::Value> origin) {
719 if (runner_)
720 runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
721 }
722
SetIsolatedWorldContentSecurityPolicy(int world_id,const std::string & policy)723 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy(
724 int world_id, const std::string& policy) {
725 if (runner_)
726 runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
727 }
728
AddOriginAccessWhitelistEntry(const std::string & source_origin,const std::string & destination_protocol,const std::string & destination_host,bool allow_destination_subdomains)729 void TestRunnerBindings::AddOriginAccessWhitelistEntry(
730 const std::string& source_origin,
731 const std::string& destination_protocol,
732 const std::string& destination_host,
733 bool allow_destination_subdomains) {
734 if (runner_) {
735 runner_->AddOriginAccessWhitelistEntry(source_origin,
736 destination_protocol,
737 destination_host,
738 allow_destination_subdomains);
739 }
740 }
741
RemoveOriginAccessWhitelistEntry(const std::string & source_origin,const std::string & destination_protocol,const std::string & destination_host,bool allow_destination_subdomains)742 void TestRunnerBindings::RemoveOriginAccessWhitelistEntry(
743 const std::string& source_origin,
744 const std::string& destination_protocol,
745 const std::string& destination_host,
746 bool allow_destination_subdomains) {
747 if (runner_) {
748 runner_->RemoveOriginAccessWhitelistEntry(source_origin,
749 destination_protocol,
750 destination_host,
751 allow_destination_subdomains);
752 }
753 }
754
HasCustomPageSizeStyle(int page_index)755 bool TestRunnerBindings::HasCustomPageSizeStyle(int page_index) {
756 if (runner_)
757 return runner_->HasCustomPageSizeStyle(page_index);
758 return false;
759 }
760
ForceRedSelectionColors()761 void TestRunnerBindings::ForceRedSelectionColors() {
762 if (runner_)
763 runner_->ForceRedSelectionColors();
764 }
765
InjectStyleSheet(const std::string & source_code,bool all_frames)766 void TestRunnerBindings::InjectStyleSheet(const std::string& source_code,
767 bool all_frames) {
768 if (runner_)
769 runner_->InjectStyleSheet(source_code, all_frames);
770 }
771
FindString(const std::string & search_text,const std::vector<std::string> & options_array)772 bool TestRunnerBindings::FindString(
773 const std::string& search_text,
774 const std::vector<std::string>& options_array) {
775 if (runner_)
776 return runner_->FindString(search_text, options_array);
777 return false;
778 }
779
SelectionAsMarkup()780 std::string TestRunnerBindings::SelectionAsMarkup() {
781 if (runner_)
782 return runner_->SelectionAsMarkup();
783 return std::string();
784 }
785
SetTextSubpixelPositioning(bool value)786 void TestRunnerBindings::SetTextSubpixelPositioning(bool value) {
787 if (runner_)
788 runner_->SetTextSubpixelPositioning(value);
789 }
790
SetPageVisibility(const std::string & new_visibility)791 void TestRunnerBindings::SetPageVisibility(const std::string& new_visibility) {
792 if (runner_)
793 runner_->SetPageVisibility(new_visibility);
794 }
795
SetTextDirection(const std::string & direction_name)796 void TestRunnerBindings::SetTextDirection(const std::string& direction_name) {
797 if (runner_)
798 runner_->SetTextDirection(direction_name);
799 }
800
UseUnfortunateSynchronousResizeMode()801 void TestRunnerBindings::UseUnfortunateSynchronousResizeMode() {
802 if (runner_)
803 runner_->UseUnfortunateSynchronousResizeMode();
804 }
805
EnableAutoResizeMode(int min_width,int min_height,int max_width,int max_height)806 bool TestRunnerBindings::EnableAutoResizeMode(int min_width,
807 int min_height,
808 int max_width,
809 int max_height) {
810 if (runner_) {
811 return runner_->EnableAutoResizeMode(min_width, min_height,
812 max_width, max_height);
813 }
814 return false;
815 }
816
DisableAutoResizeMode(int new_width,int new_height)817 bool TestRunnerBindings::DisableAutoResizeMode(int new_width, int new_height) {
818 if (runner_)
819 return runner_->DisableAutoResizeMode(new_width, new_height);
820 return false;
821 }
822
SetMockDeviceMotion(gin::Arguments * args)823 void TestRunnerBindings::SetMockDeviceMotion(gin::Arguments* args) {
824 if (!runner_)
825 return;
826
827 bool has_acceleration_x;
828 double acceleration_x;
829 bool has_acceleration_y;
830 double acceleration_y;
831 bool has_acceleration_z;
832 double acceleration_z;
833 bool has_acceleration_including_gravity_x;
834 double acceleration_including_gravity_x;
835 bool has_acceleration_including_gravity_y;
836 double acceleration_including_gravity_y;
837 bool has_acceleration_including_gravity_z;
838 double acceleration_including_gravity_z;
839 bool has_rotation_rate_alpha;
840 double rotation_rate_alpha;
841 bool has_rotation_rate_beta;
842 double rotation_rate_beta;
843 bool has_rotation_rate_gamma;
844 double rotation_rate_gamma;
845 double interval;
846
847 args->GetNext(&has_acceleration_x);
848 args->GetNext(& acceleration_x);
849 args->GetNext(&has_acceleration_y);
850 args->GetNext(& acceleration_y);
851 args->GetNext(&has_acceleration_z);
852 args->GetNext(& acceleration_z);
853 args->GetNext(&has_acceleration_including_gravity_x);
854 args->GetNext(& acceleration_including_gravity_x);
855 args->GetNext(&has_acceleration_including_gravity_y);
856 args->GetNext(& acceleration_including_gravity_y);
857 args->GetNext(&has_acceleration_including_gravity_z);
858 args->GetNext(& acceleration_including_gravity_z);
859 args->GetNext(&has_rotation_rate_alpha);
860 args->GetNext(& rotation_rate_alpha);
861 args->GetNext(&has_rotation_rate_beta);
862 args->GetNext(& rotation_rate_beta);
863 args->GetNext(&has_rotation_rate_gamma);
864 args->GetNext(& rotation_rate_gamma);
865 args->GetNext(& interval);
866
867 runner_->SetMockDeviceMotion(has_acceleration_x, acceleration_x,
868 has_acceleration_y, acceleration_y,
869 has_acceleration_z, acceleration_z,
870 has_acceleration_including_gravity_x,
871 acceleration_including_gravity_x,
872 has_acceleration_including_gravity_y,
873 acceleration_including_gravity_y,
874 has_acceleration_including_gravity_z,
875 acceleration_including_gravity_z,
876 has_rotation_rate_alpha,
877 rotation_rate_alpha,
878 has_rotation_rate_beta,
879 rotation_rate_beta,
880 has_rotation_rate_gamma,
881 rotation_rate_gamma,
882 interval);
883 }
884
SetMockDeviceOrientation(gin::Arguments * args)885 void TestRunnerBindings::SetMockDeviceOrientation(gin::Arguments* args) {
886 if (!runner_)
887 return;
888
889 bool has_alpha;
890 double alpha;
891 bool has_beta;
892 double beta;
893 bool has_gamma;
894 double gamma;
895 bool has_absolute;
896 bool absolute;
897
898 args->GetNext(&has_alpha);
899 args->GetNext(&alpha);
900 args->GetNext(&has_beta);
901 args->GetNext(&beta);
902 args->GetNext(&has_gamma);
903 args->GetNext(&gamma);
904 args->GetNext(&has_absolute);
905 args->GetNext(&absolute);
906
907 runner_->SetMockDeviceOrientation(has_alpha, alpha,
908 has_beta, beta,
909 has_gamma, gamma,
910 has_absolute, absolute);
911 }
912
SetMockScreenOrientation(const std::string & orientation)913 void TestRunnerBindings::SetMockScreenOrientation(const std::string& orientation) {
914 if (!runner_)
915 return;
916
917 runner_->SetMockScreenOrientation(orientation);
918 }
919
DidChangeBatteryStatus(bool charging,double chargingTime,double dischargingTime,double level)920 void TestRunnerBindings::DidChangeBatteryStatus(bool charging,
921 double chargingTime,
922 double dischargingTime,
923 double level) {
924 if (runner_) {
925 runner_->DidChangeBatteryStatus(charging, chargingTime,
926 dischargingTime, level);
927 }
928 }
929
ResetBatteryStatus()930 void TestRunnerBindings::ResetBatteryStatus() {
931 if (runner_)
932 runner_->ResetBatteryStatus();
933 }
934
DidAcquirePointerLock()935 void TestRunnerBindings::DidAcquirePointerLock() {
936 if (runner_)
937 runner_->DidAcquirePointerLock();
938 }
939
DidNotAcquirePointerLock()940 void TestRunnerBindings::DidNotAcquirePointerLock() {
941 if (runner_)
942 runner_->DidNotAcquirePointerLock();
943 }
944
DidLosePointerLock()945 void TestRunnerBindings::DidLosePointerLock() {
946 if (runner_)
947 runner_->DidLosePointerLock();
948 }
949
SetPointerLockWillFailSynchronously()950 void TestRunnerBindings::SetPointerLockWillFailSynchronously() {
951 if (runner_)
952 runner_->SetPointerLockWillFailSynchronously();
953 }
954
SetPointerLockWillRespondAsynchronously()955 void TestRunnerBindings::SetPointerLockWillRespondAsynchronously() {
956 if (runner_)
957 runner_->SetPointerLockWillRespondAsynchronously();
958 }
959
SetPopupBlockingEnabled(bool block_popups)960 void TestRunnerBindings::SetPopupBlockingEnabled(bool block_popups) {
961 if (runner_)
962 runner_->SetPopupBlockingEnabled(block_popups);
963 }
964
SetJavaScriptCanAccessClipboard(bool can_access)965 void TestRunnerBindings::SetJavaScriptCanAccessClipboard(bool can_access) {
966 if (runner_)
967 runner_->SetJavaScriptCanAccessClipboard(can_access);
968 }
969
SetXSSAuditorEnabled(bool enabled)970 void TestRunnerBindings::SetXSSAuditorEnabled(bool enabled) {
971 if (runner_)
972 runner_->SetXSSAuditorEnabled(enabled);
973 }
974
SetAllowUniversalAccessFromFileURLs(bool allow)975 void TestRunnerBindings::SetAllowUniversalAccessFromFileURLs(bool allow) {
976 if (runner_)
977 runner_->SetAllowUniversalAccessFromFileURLs(allow);
978 }
979
SetAllowFileAccessFromFileURLs(bool allow)980 void TestRunnerBindings::SetAllowFileAccessFromFileURLs(bool allow) {
981 if (runner_)
982 runner_->SetAllowFileAccessFromFileURLs(allow);
983 }
984
OverridePreference(const std::string key,v8::Handle<v8::Value> value)985 void TestRunnerBindings::OverridePreference(const std::string key,
986 v8::Handle<v8::Value> value) {
987 if (runner_)
988 runner_->OverridePreference(key, value);
989 }
990
SetAcceptLanguages(const std::string & accept_languages)991 void TestRunnerBindings::SetAcceptLanguages(
992 const std::string& accept_languages) {
993 if (!runner_)
994 return;
995
996 runner_->SetAcceptLanguages(accept_languages);
997 }
998
SetPluginsEnabled(bool enabled)999 void TestRunnerBindings::SetPluginsEnabled(bool enabled) {
1000 if (runner_)
1001 runner_->SetPluginsEnabled(enabled);
1002 }
1003
DumpEditingCallbacks()1004 void TestRunnerBindings::DumpEditingCallbacks() {
1005 if (runner_)
1006 runner_->DumpEditingCallbacks();
1007 }
1008
DumpAsMarkup()1009 void TestRunnerBindings::DumpAsMarkup() {
1010 if (runner_)
1011 runner_->DumpAsMarkup();
1012 }
1013
DumpAsText()1014 void TestRunnerBindings::DumpAsText() {
1015 if (runner_)
1016 runner_->DumpAsText();
1017 }
1018
DumpAsTextWithPixelResults()1019 void TestRunnerBindings::DumpAsTextWithPixelResults() {
1020 if (runner_)
1021 runner_->DumpAsTextWithPixelResults();
1022 }
1023
DumpChildFrameScrollPositions()1024 void TestRunnerBindings::DumpChildFrameScrollPositions() {
1025 if (runner_)
1026 runner_->DumpChildFrameScrollPositions();
1027 }
1028
DumpChildFramesAsText()1029 void TestRunnerBindings::DumpChildFramesAsText() {
1030 if (runner_)
1031 runner_->DumpChildFramesAsText();
1032 }
1033
DumpChildFramesAsMarkup()1034 void TestRunnerBindings::DumpChildFramesAsMarkup() {
1035 if (runner_)
1036 runner_->DumpChildFramesAsMarkup();
1037 }
1038
DumpIconChanges()1039 void TestRunnerBindings::DumpIconChanges() {
1040 if (runner_)
1041 runner_->DumpIconChanges();
1042 }
1043
SetAudioData(const gin::ArrayBufferView & view)1044 void TestRunnerBindings::SetAudioData(const gin::ArrayBufferView& view) {
1045 if (runner_)
1046 runner_->SetAudioData(view);
1047 }
1048
DumpFrameLoadCallbacks()1049 void TestRunnerBindings::DumpFrameLoadCallbacks() {
1050 if (runner_)
1051 runner_->DumpFrameLoadCallbacks();
1052 }
1053
DumpPingLoaderCallbacks()1054 void TestRunnerBindings::DumpPingLoaderCallbacks() {
1055 if (runner_)
1056 runner_->DumpPingLoaderCallbacks();
1057 }
1058
DumpUserGestureInFrameLoadCallbacks()1059 void TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks() {
1060 if (runner_)
1061 runner_->DumpUserGestureInFrameLoadCallbacks();
1062 }
1063
DumpTitleChanges()1064 void TestRunnerBindings::DumpTitleChanges() {
1065 if (runner_)
1066 runner_->DumpTitleChanges();
1067 }
1068
DumpCreateView()1069 void TestRunnerBindings::DumpCreateView() {
1070 if (runner_)
1071 runner_->DumpCreateView();
1072 }
1073
SetCanOpenWindows()1074 void TestRunnerBindings::SetCanOpenWindows() {
1075 if (runner_)
1076 runner_->SetCanOpenWindows();
1077 }
1078
DumpResourceLoadCallbacks()1079 void TestRunnerBindings::DumpResourceLoadCallbacks() {
1080 if (runner_)
1081 runner_->DumpResourceLoadCallbacks();
1082 }
1083
DumpResourceRequestCallbacks()1084 void TestRunnerBindings::DumpResourceRequestCallbacks() {
1085 if (runner_)
1086 runner_->DumpResourceRequestCallbacks();
1087 }
1088
DumpResourceResponseMIMETypes()1089 void TestRunnerBindings::DumpResourceResponseMIMETypes() {
1090 if (runner_)
1091 runner_->DumpResourceResponseMIMETypes();
1092 }
1093
SetImagesAllowed(bool allowed)1094 void TestRunnerBindings::SetImagesAllowed(bool allowed) {
1095 if (runner_)
1096 runner_->SetImagesAllowed(allowed);
1097 }
1098
SetMediaAllowed(bool allowed)1099 void TestRunnerBindings::SetMediaAllowed(bool allowed) {
1100 if (runner_)
1101 runner_->SetMediaAllowed(allowed);
1102 }
1103
SetScriptsAllowed(bool allowed)1104 void TestRunnerBindings::SetScriptsAllowed(bool allowed) {
1105 if (runner_)
1106 runner_->SetScriptsAllowed(allowed);
1107 }
1108
SetStorageAllowed(bool allowed)1109 void TestRunnerBindings::SetStorageAllowed(bool allowed) {
1110 if (runner_)
1111 runner_->SetStorageAllowed(allowed);
1112 }
1113
SetPluginsAllowed(bool allowed)1114 void TestRunnerBindings::SetPluginsAllowed(bool allowed) {
1115 if (runner_)
1116 runner_->SetPluginsAllowed(allowed);
1117 }
1118
SetAllowDisplayOfInsecureContent(bool allowed)1119 void TestRunnerBindings::SetAllowDisplayOfInsecureContent(bool allowed) {
1120 if (runner_)
1121 runner_->SetAllowDisplayOfInsecureContent(allowed);
1122 }
1123
SetAllowRunningOfInsecureContent(bool allowed)1124 void TestRunnerBindings::SetAllowRunningOfInsecureContent(bool allowed) {
1125 if (runner_)
1126 runner_->SetAllowRunningOfInsecureContent(allowed);
1127 }
1128
DumpPermissionClientCallbacks()1129 void TestRunnerBindings::DumpPermissionClientCallbacks() {
1130 if (runner_)
1131 runner_->DumpPermissionClientCallbacks();
1132 }
1133
DumpWindowStatusChanges()1134 void TestRunnerBindings::DumpWindowStatusChanges() {
1135 if (runner_)
1136 runner_->DumpWindowStatusChanges();
1137 }
1138
DumpProgressFinishedCallback()1139 void TestRunnerBindings::DumpProgressFinishedCallback() {
1140 if (runner_)
1141 runner_->DumpProgressFinishedCallback();
1142 }
1143
DumpSpellCheckCallbacks()1144 void TestRunnerBindings::DumpSpellCheckCallbacks() {
1145 if (runner_)
1146 runner_->DumpSpellCheckCallbacks();
1147 }
1148
DumpBackForwardList()1149 void TestRunnerBindings::DumpBackForwardList() {
1150 if (runner_)
1151 runner_->DumpBackForwardList();
1152 }
1153
DumpSelectionRect()1154 void TestRunnerBindings::DumpSelectionRect() {
1155 if (runner_)
1156 runner_->DumpSelectionRect();
1157 }
1158
SetPrinting()1159 void TestRunnerBindings::SetPrinting() {
1160 if (runner_)
1161 runner_->SetPrinting();
1162 }
1163
SetShouldStayOnPageAfterHandlingBeforeUnload(bool value)1164 void TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload(
1165 bool value) {
1166 if (runner_)
1167 runner_->SetShouldStayOnPageAfterHandlingBeforeUnload(value);
1168 }
1169
SetWillSendRequestClearHeader(const std::string & header)1170 void TestRunnerBindings::SetWillSendRequestClearHeader(
1171 const std::string& header) {
1172 if (runner_)
1173 runner_->SetWillSendRequestClearHeader(header);
1174 }
1175
DumpResourceRequestPriorities()1176 void TestRunnerBindings::DumpResourceRequestPriorities() {
1177 if (runner_)
1178 runner_->DumpResourceRequestPriorities();
1179 }
1180
SetUseMockTheme(bool use)1181 void TestRunnerBindings::SetUseMockTheme(bool use) {
1182 if (runner_)
1183 runner_->SetUseMockTheme(use);
1184 }
1185
WaitUntilExternalURLLoad()1186 void TestRunnerBindings::WaitUntilExternalURLLoad() {
1187 if (runner_)
1188 runner_->WaitUntilExternalURLLoad();
1189 }
1190
ShowWebInspector(gin::Arguments * args)1191 void TestRunnerBindings::ShowWebInspector(gin::Arguments* args) {
1192 if (runner_) {
1193 std::string settings;
1194 args->GetNext(&settings);
1195 std::string frontend_url;
1196 args->GetNext(&frontend_url);
1197 runner_->ShowWebInspector(settings, frontend_url);
1198 }
1199 }
1200
CloseWebInspector()1201 void TestRunnerBindings::CloseWebInspector() {
1202 if (runner_)
1203 runner_->CloseWebInspector();
1204 }
1205
IsChooserShown()1206 bool TestRunnerBindings::IsChooserShown() {
1207 if (runner_)
1208 return runner_->IsChooserShown();
1209 return false;
1210 }
1211
EvaluateInWebInspector(int call_id,const std::string & script)1212 void TestRunnerBindings::EvaluateInWebInspector(int call_id,
1213 const std::string& script) {
1214 if (runner_)
1215 runner_->EvaluateInWebInspector(call_id, script);
1216 }
1217
ClearAllDatabases()1218 void TestRunnerBindings::ClearAllDatabases() {
1219 if (runner_)
1220 runner_->ClearAllDatabases();
1221 }
1222
SetDatabaseQuota(int quota)1223 void TestRunnerBindings::SetDatabaseQuota(int quota) {
1224 if (runner_)
1225 runner_->SetDatabaseQuota(quota);
1226 }
1227
SetAlwaysAcceptCookies(bool accept)1228 void TestRunnerBindings::SetAlwaysAcceptCookies(bool accept) {
1229 if (runner_)
1230 runner_->SetAlwaysAcceptCookies(accept);
1231 }
1232
SetWindowIsKey(bool value)1233 void TestRunnerBindings::SetWindowIsKey(bool value) {
1234 if (runner_)
1235 runner_->SetWindowIsKey(value);
1236 }
1237
PathToLocalResource(const std::string & path)1238 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) {
1239 if (runner_)
1240 return runner_->PathToLocalResource(path);
1241 return std::string();
1242 }
1243
SetBackingScaleFactor(double value,v8::Handle<v8::Function> callback)1244 void TestRunnerBindings::SetBackingScaleFactor(
1245 double value, v8::Handle<v8::Function> callback) {
1246 if (runner_)
1247 runner_->SetBackingScaleFactor(value, callback);
1248 }
1249
SetColorProfile(const std::string & name,v8::Handle<v8::Function> callback)1250 void TestRunnerBindings::SetColorProfile(
1251 const std::string& name, v8::Handle<v8::Function> callback) {
1252 if (runner_)
1253 runner_->SetColorProfile(name, callback);
1254 }
1255
SetPOSIXLocale(const std::string & locale)1256 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) {
1257 if (runner_)
1258 runner_->SetPOSIXLocale(locale);
1259 }
1260
SetMIDIAccessorResult(bool result)1261 void TestRunnerBindings::SetMIDIAccessorResult(bool result) {
1262 if (runner_)
1263 runner_->SetMIDIAccessorResult(result);
1264 }
1265
SetMIDISysexPermission(bool value)1266 void TestRunnerBindings::SetMIDISysexPermission(bool value) {
1267 if (runner_)
1268 runner_->SetMIDISysexPermission(value);
1269 }
1270
GrantWebNotificationPermission(gin::Arguments * args)1271 void TestRunnerBindings::GrantWebNotificationPermission(gin::Arguments* args) {
1272 if (runner_) {
1273 std::string origin;
1274 bool permission_granted = true;
1275 args->GetNext(&origin);
1276 args->GetNext(&permission_granted);
1277 return runner_->GrantWebNotificationPermission(origin, permission_granted);
1278 }
1279 }
1280
SimulateWebNotificationClick(const std::string & value)1281 bool TestRunnerBindings::SimulateWebNotificationClick(
1282 const std::string& value) {
1283 if (runner_)
1284 return runner_->SimulateWebNotificationClick(value);
1285 return false;
1286 }
1287
AddMockSpeechRecognitionResult(const std::string & transcript,double confidence)1288 void TestRunnerBindings::AddMockSpeechRecognitionResult(
1289 const std::string& transcript, double confidence) {
1290 if (runner_)
1291 runner_->AddMockSpeechRecognitionResult(transcript, confidence);
1292 }
1293
SetMockSpeechRecognitionError(const std::string & error,const std::string & message)1294 void TestRunnerBindings::SetMockSpeechRecognitionError(
1295 const std::string& error, const std::string& message) {
1296 if (runner_)
1297 runner_->SetMockSpeechRecognitionError(error, message);
1298 }
1299
WasMockSpeechRecognitionAborted()1300 bool TestRunnerBindings::WasMockSpeechRecognitionAborted() {
1301 if (runner_)
1302 return runner_->WasMockSpeechRecognitionAborted();
1303 return false;
1304 }
1305
AddWebPageOverlay()1306 void TestRunnerBindings::AddWebPageOverlay() {
1307 if (runner_)
1308 runner_->AddWebPageOverlay();
1309 }
1310
RemoveWebPageOverlay()1311 void TestRunnerBindings::RemoveWebPageOverlay() {
1312 if (runner_)
1313 runner_->RemoveWebPageOverlay();
1314 }
1315
DisplayAsync()1316 void TestRunnerBindings::DisplayAsync() {
1317 if (runner_)
1318 runner_->DisplayAsync();
1319 }
1320
DisplayAsyncThen(v8::Handle<v8::Function> callback)1321 void TestRunnerBindings::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
1322 if (runner_)
1323 runner_->DisplayAsyncThen(callback);
1324 }
1325
CapturePixelsAsyncThen(v8::Handle<v8::Function> callback)1326 void TestRunnerBindings::CapturePixelsAsyncThen(
1327 v8::Handle<v8::Function> callback) {
1328 if (runner_)
1329 runner_->CapturePixelsAsyncThen(callback);
1330 }
1331
SetCustomTextOutput(std::string output)1332 void TestRunnerBindings::SetCustomTextOutput(std::string output) {
1333 runner_->setCustomTextOutput(output);
1334 }
1335
SetViewSourceForFrame(const std::string & name,bool enabled)1336 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
1337 bool enabled) {
1338 if (runner_ && runner_->web_view_) {
1339 WebFrame* target_frame =
1340 runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
1341 if (target_frame)
1342 target_frame->enableViewSourceMode(enabled);
1343 }
1344 }
1345
setMockPushClientSuccess(const std::string & end_point,const std::string & registration_id)1346 void TestRunnerBindings::setMockPushClientSuccess(
1347 const std::string& end_point, const std::string& registration_id) {
1348 if (!runner_)
1349 return;
1350 runner_->SetMockPushClientSuccess(end_point, registration_id);
1351 }
1352
setMockPushClientError(const std::string & message)1353 void TestRunnerBindings::setMockPushClientError(const std::string& message) {
1354 if (!runner_)
1355 return;
1356 runner_->SetMockPushClientError(message);
1357 }
1358
GlobalFlag()1359 bool TestRunnerBindings::GlobalFlag() {
1360 if (runner_)
1361 return runner_->global_flag_;
1362 return false;
1363 }
1364
SetGlobalFlag(bool value)1365 void TestRunnerBindings::SetGlobalFlag(bool value) {
1366 if (runner_)
1367 runner_->global_flag_ = value;
1368 }
1369
PlatformName()1370 std::string TestRunnerBindings::PlatformName() {
1371 if (runner_)
1372 return runner_->platform_name_;
1373 return std::string();
1374 }
1375
TooltipText()1376 std::string TestRunnerBindings::TooltipText() {
1377 if (runner_)
1378 return runner_->tooltip_text_;
1379 return std::string();
1380 }
1381
DisableNotifyDone()1382 bool TestRunnerBindings::DisableNotifyDone() {
1383 if (runner_)
1384 return runner_->disable_notify_done_;
1385 return false;
1386 }
1387
WebHistoryItemCount()1388 int TestRunnerBindings::WebHistoryItemCount() {
1389 if (runner_)
1390 return runner_->web_history_item_count_;
1391 return false;
1392 }
1393
InterceptPostMessage()1394 bool TestRunnerBindings::InterceptPostMessage() {
1395 if (runner_)
1396 return runner_->intercept_post_message_;
1397 return false;
1398 }
1399
SetInterceptPostMessage(bool value)1400 void TestRunnerBindings::SetInterceptPostMessage(bool value) {
1401 if (runner_)
1402 runner_->intercept_post_message_ = value;
1403 }
1404
NotImplemented(const gin::Arguments & args)1405 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
1406 }
1407
1408 class TestPageOverlay : public WebPageOverlay {
1409 public:
TestPageOverlay(WebView * web_view)1410 explicit TestPageOverlay(WebView* web_view)
1411 : web_view_(web_view) {
1412 }
~TestPageOverlay()1413 virtual ~TestPageOverlay() {}
1414
paintPageOverlay(WebCanvas * canvas)1415 virtual void paintPageOverlay(WebCanvas* canvas) OVERRIDE {
1416 SkRect rect = SkRect::MakeWH(web_view_->size().width,
1417 web_view_->size().height);
1418 SkPaint paint;
1419 paint.setColor(SK_ColorCYAN);
1420 paint.setStyle(SkPaint::kFill_Style);
1421 canvas->drawRect(rect, paint);
1422 }
1423
1424 private:
1425 WebView* web_view_;
1426 };
1427
WorkQueue(TestRunner * controller)1428 TestRunner::WorkQueue::WorkQueue(TestRunner* controller)
1429 : frozen_(false)
1430 , controller_(controller) {}
1431
~WorkQueue()1432 TestRunner::WorkQueue::~WorkQueue() {
1433 Reset();
1434 }
1435
ProcessWorkSoon()1436 void TestRunner::WorkQueue::ProcessWorkSoon() {
1437 if (controller_->topLoadingFrame())
1438 return;
1439
1440 if (!queue_.empty()) {
1441 // We delay processing queued work to avoid recursion problems.
1442 controller_->delegate_->postTask(new WorkQueueTask(this));
1443 } else if (!controller_->wait_until_done_) {
1444 controller_->delegate_->testFinished();
1445 }
1446 }
1447
Reset()1448 void TestRunner::WorkQueue::Reset() {
1449 frozen_ = false;
1450 while (!queue_.empty()) {
1451 delete queue_.front();
1452 queue_.pop_front();
1453 }
1454 }
1455
AddWork(WorkItem * work)1456 void TestRunner::WorkQueue::AddWork(WorkItem* work) {
1457 if (frozen_) {
1458 delete work;
1459 return;
1460 }
1461 queue_.push_back(work);
1462 }
1463
ProcessWork()1464 void TestRunner::WorkQueue::ProcessWork() {
1465 // Quit doing work once a load is in progress.
1466 while (!queue_.empty()) {
1467 bool startedLoad = queue_.front()->Run(controller_->delegate_,
1468 controller_->web_view_);
1469 delete queue_.front();
1470 queue_.pop_front();
1471 if (startedLoad)
1472 return;
1473 }
1474
1475 if (!controller_->wait_until_done_ && !controller_->topLoadingFrame())
1476 controller_->delegate_->testFinished();
1477 }
1478
runIfValid()1479 void TestRunner::WorkQueue::WorkQueueTask::runIfValid() {
1480 m_object->ProcessWork();
1481 }
1482
TestRunner(TestInterfaces * interfaces)1483 TestRunner::TestRunner(TestInterfaces* interfaces)
1484 : test_is_running_(false),
1485 close_remaining_windows_(false),
1486 work_queue_(this),
1487 disable_notify_done_(false),
1488 web_history_item_count_(0),
1489 intercept_post_message_(false),
1490 test_interfaces_(interfaces),
1491 delegate_(NULL),
1492 web_view_(NULL),
1493 page_overlay_(NULL),
1494 web_permissions_(new WebPermissions()),
1495 notification_presenter_(new NotificationPresenter()),
1496 weak_factory_(this) {}
1497
~TestRunner()1498 TestRunner::~TestRunner() {}
1499
Install(WebFrame * frame)1500 void TestRunner::Install(WebFrame* frame) {
1501 TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), frame);
1502 }
1503
SetDelegate(WebTestDelegate * delegate)1504 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
1505 delegate_ = delegate;
1506 web_permissions_->SetDelegate(delegate);
1507 notification_presenter_->set_delegate(delegate);
1508 }
1509
SetWebView(WebView * webView,WebTestProxyBase * proxy)1510 void TestRunner::SetWebView(WebView* webView, WebTestProxyBase* proxy) {
1511 web_view_ = webView;
1512 proxy_ = proxy;
1513 }
1514
Reset()1515 void TestRunner::Reset() {
1516 if (web_view_) {
1517 web_view_->setZoomLevel(0);
1518 web_view_->setTextZoomFactor(1);
1519 web_view_->setTabKeyCyclesThroughElements(true);
1520 #if !defined(__APPLE__) && !defined(WIN32) // Actually, TOOLKIT_GTK
1521 // (Constants copied because we can't depend on the header that defined
1522 // them from this file.)
1523 web_view_->setSelectionColors(
1524 0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
1525 #endif
1526 web_view_->removeInjectedStyleSheets();
1527 web_view_->setVisibilityState(WebPageVisibilityStateVisible, true);
1528 web_view_->mainFrame()->enableViewSourceMode(false);
1529
1530 if (page_overlay_) {
1531 web_view_->removePageOverlay(page_overlay_);
1532 delete page_overlay_;
1533 page_overlay_ = NULL;
1534 }
1535 }
1536
1537 top_loading_frame_ = NULL;
1538 wait_until_done_ = false;
1539 wait_until_external_url_load_ = false;
1540 policy_delegate_enabled_ = false;
1541 policy_delegate_is_permissive_ = false;
1542 policy_delegate_should_notify_done_ = false;
1543
1544 WebSecurityPolicy::resetOriginAccessWhitelists();
1545 #if defined(__linux__) || defined(ANDROID)
1546 WebFontRendering::setSubpixelPositioning(false);
1547 #endif
1548
1549 if (delegate_) {
1550 // Reset the default quota for each origin to 5MB
1551 delegate_->setDatabaseQuota(5 * 1024 * 1024);
1552 delegate_->setDeviceColorProfile("sRGB");
1553 delegate_->setDeviceScaleFactor(1);
1554 delegate_->setAcceptAllCookies(false);
1555 delegate_->setLocale("");
1556 delegate_->useUnfortunateSynchronousResizeMode(false);
1557 delegate_->disableAutoResizeMode(WebSize());
1558 delegate_->deleteAllCookies();
1559 delegate_->resetScreenOrientation();
1560 ResetBatteryStatus();
1561 }
1562
1563 dump_editting_callbacks_ = false;
1564 dump_as_text_ = false;
1565 dump_as_markup_ = false;
1566 generate_pixel_results_ = true;
1567 dump_child_frame_scroll_positions_ = false;
1568 dump_child_frames_as_markup_ = false;
1569 dump_child_frames_as_text_ = false;
1570 dump_icon_changes_ = false;
1571 dump_as_audio_ = false;
1572 dump_frame_load_callbacks_ = false;
1573 dump_ping_loader_callbacks_ = false;
1574 dump_user_gesture_in_frame_load_callbacks_ = false;
1575 dump_title_changes_ = false;
1576 dump_create_view_ = false;
1577 can_open_windows_ = false;
1578 dump_resource_load_callbacks_ = false;
1579 dump_resource_request_callbacks_ = false;
1580 dump_resource_reqponse_mime_types_ = false;
1581 dump_window_status_changes_ = false;
1582 dump_progress_finished_callback_ = false;
1583 dump_spell_check_callbacks_ = false;
1584 dump_back_forward_list_ = false;
1585 dump_selection_rect_ = false;
1586 test_repaint_ = false;
1587 sweep_horizontally_ = false;
1588 is_printing_ = false;
1589 midi_accessor_result_ = true;
1590 should_stay_on_page_after_handling_before_unload_ = false;
1591 should_dump_resource_priorities_ = false;
1592 has_custom_text_output_ = false;
1593 custom_text_output_.clear();
1594
1595 http_headers_to_clear_.clear();
1596
1597 global_flag_ = false;
1598 platform_name_ = "chromium";
1599 tooltip_text_ = std::string();
1600 disable_notify_done_ = false;
1601 web_history_item_count_ = 0;
1602 intercept_post_message_ = false;
1603
1604 web_permissions_->Reset();
1605
1606 notification_presenter_->Reset();
1607 use_mock_theme_ = true;
1608 pointer_locked_ = false;
1609 pointer_lock_planned_result_ = PointerLockWillSucceed;
1610
1611 task_list_.revokeAll();
1612 work_queue_.Reset();
1613
1614 if (close_remaining_windows_ && delegate_)
1615 delegate_->closeRemainingWindows();
1616 else
1617 close_remaining_windows_ = true;
1618 }
1619
SetTestIsRunning(bool running)1620 void TestRunner::SetTestIsRunning(bool running) {
1621 test_is_running_ = running;
1622 }
1623
InvokeCallback(scoped_ptr<InvokeCallbackTask> task)1624 void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
1625 delegate_->postTask(task.release());
1626 }
1627
shouldDumpEditingCallbacks() const1628 bool TestRunner::shouldDumpEditingCallbacks() const {
1629 return dump_editting_callbacks_;
1630 }
1631
shouldDumpAsText()1632 bool TestRunner::shouldDumpAsText() {
1633 CheckResponseMimeType();
1634 return dump_as_text_;
1635 }
1636
setShouldDumpAsText(bool value)1637 void TestRunner::setShouldDumpAsText(bool value) {
1638 dump_as_text_ = value;
1639 }
1640
shouldDumpAsMarkup()1641 bool TestRunner::shouldDumpAsMarkup() {
1642 return dump_as_markup_;
1643 }
1644
setShouldDumpAsMarkup(bool value)1645 void TestRunner::setShouldDumpAsMarkup(bool value) {
1646 dump_as_markup_ = value;
1647 }
1648
shouldDumpAsCustomText() const1649 bool TestRunner::shouldDumpAsCustomText() const {
1650 return has_custom_text_output_;
1651 }
1652
customDumpText() const1653 std::string TestRunner::customDumpText() const {
1654 return custom_text_output_;
1655 }
1656
setCustomTextOutput(std::string text)1657 void TestRunner::setCustomTextOutput(std::string text) {
1658 custom_text_output_ = text;
1659 has_custom_text_output_ = true;
1660 }
1661
ShouldGeneratePixelResults()1662 bool TestRunner::ShouldGeneratePixelResults() {
1663 CheckResponseMimeType();
1664 return generate_pixel_results_;
1665 }
1666
setShouldGeneratePixelResults(bool value)1667 void TestRunner::setShouldGeneratePixelResults(bool value) {
1668 generate_pixel_results_ = value;
1669 }
1670
shouldDumpChildFrameScrollPositions() const1671 bool TestRunner::shouldDumpChildFrameScrollPositions() const {
1672 return dump_child_frame_scroll_positions_;
1673 }
1674
shouldDumpChildFramesAsMarkup() const1675 bool TestRunner::shouldDumpChildFramesAsMarkup() const {
1676 return dump_child_frames_as_markup_;
1677 }
1678
shouldDumpChildFramesAsText() const1679 bool TestRunner::shouldDumpChildFramesAsText() const {
1680 return dump_child_frames_as_text_;
1681 }
1682
ShouldDumpAsAudio() const1683 bool TestRunner::ShouldDumpAsAudio() const {
1684 return dump_as_audio_;
1685 }
1686
GetAudioData(std::vector<unsigned char> * buffer_view) const1687 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const {
1688 *buffer_view = audio_data_;
1689 }
1690
shouldDumpFrameLoadCallbacks() const1691 bool TestRunner::shouldDumpFrameLoadCallbacks() const {
1692 return test_is_running_ && dump_frame_load_callbacks_;
1693 }
1694
setShouldDumpFrameLoadCallbacks(bool value)1695 void TestRunner::setShouldDumpFrameLoadCallbacks(bool value) {
1696 dump_frame_load_callbacks_ = value;
1697 }
1698
shouldDumpPingLoaderCallbacks() const1699 bool TestRunner::shouldDumpPingLoaderCallbacks() const {
1700 return test_is_running_ && dump_ping_loader_callbacks_;
1701 }
1702
setShouldDumpPingLoaderCallbacks(bool value)1703 void TestRunner::setShouldDumpPingLoaderCallbacks(bool value) {
1704 dump_ping_loader_callbacks_ = value;
1705 }
1706
setShouldEnableViewSource(bool value)1707 void TestRunner::setShouldEnableViewSource(bool value) {
1708 web_view_->mainFrame()->enableViewSourceMode(value);
1709 }
1710
shouldDumpUserGestureInFrameLoadCallbacks() const1711 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const {
1712 return test_is_running_ && dump_user_gesture_in_frame_load_callbacks_;
1713 }
1714
shouldDumpTitleChanges() const1715 bool TestRunner::shouldDumpTitleChanges() const {
1716 return dump_title_changes_;
1717 }
1718
shouldDumpIconChanges() const1719 bool TestRunner::shouldDumpIconChanges() const {
1720 return dump_icon_changes_;
1721 }
1722
shouldDumpCreateView() const1723 bool TestRunner::shouldDumpCreateView() const {
1724 return dump_create_view_;
1725 }
1726
canOpenWindows() const1727 bool TestRunner::canOpenWindows() const {
1728 return can_open_windows_;
1729 }
1730
shouldDumpResourceLoadCallbacks() const1731 bool TestRunner::shouldDumpResourceLoadCallbacks() const {
1732 return test_is_running_ && dump_resource_load_callbacks_;
1733 }
1734
shouldDumpResourceRequestCallbacks() const1735 bool TestRunner::shouldDumpResourceRequestCallbacks() const {
1736 return test_is_running_ && dump_resource_request_callbacks_;
1737 }
1738
shouldDumpResourceResponseMIMETypes() const1739 bool TestRunner::shouldDumpResourceResponseMIMETypes() const {
1740 return test_is_running_ && dump_resource_reqponse_mime_types_;
1741 }
1742
GetWebPermissions() const1743 WebPermissionClient* TestRunner::GetWebPermissions() const {
1744 return web_permissions_.get();
1745 }
1746
shouldDumpStatusCallbacks() const1747 bool TestRunner::shouldDumpStatusCallbacks() const {
1748 return dump_window_status_changes_;
1749 }
1750
shouldDumpProgressFinishedCallback() const1751 bool TestRunner::shouldDumpProgressFinishedCallback() const {
1752 return dump_progress_finished_callback_;
1753 }
1754
shouldDumpSpellCheckCallbacks() const1755 bool TestRunner::shouldDumpSpellCheckCallbacks() const {
1756 return dump_spell_check_callbacks_;
1757 }
1758
ShouldDumpBackForwardList() const1759 bool TestRunner::ShouldDumpBackForwardList() const {
1760 return dump_back_forward_list_;
1761 }
1762
shouldDumpSelectionRect() const1763 bool TestRunner::shouldDumpSelectionRect() const {
1764 return dump_selection_rect_;
1765 }
1766
isPrinting() const1767 bool TestRunner::isPrinting() const {
1768 return is_printing_;
1769 }
1770
shouldStayOnPageAfterHandlingBeforeUnload() const1771 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const {
1772 return should_stay_on_page_after_handling_before_unload_;
1773 }
1774
shouldWaitUntilExternalURLLoad() const1775 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
1776 return wait_until_external_url_load_;
1777 }
1778
httpHeadersToClear() const1779 const std::set<std::string>* TestRunner::httpHeadersToClear() const {
1780 return &http_headers_to_clear_;
1781 }
1782
setTopLoadingFrame(WebFrame * frame,bool clear)1783 void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear) {
1784 if (frame->top()->view() != web_view_)
1785 return;
1786 if (!test_is_running_)
1787 return;
1788 if (clear) {
1789 top_loading_frame_ = NULL;
1790 LocationChangeDone();
1791 } else if (!top_loading_frame_) {
1792 top_loading_frame_ = frame;
1793 }
1794 }
1795
topLoadingFrame() const1796 WebFrame* TestRunner::topLoadingFrame() const {
1797 return top_loading_frame_;
1798 }
1799
policyDelegateDone()1800 void TestRunner::policyDelegateDone() {
1801 DCHECK(wait_until_done_);
1802 delegate_->testFinished();
1803 wait_until_done_ = false;
1804 }
1805
policyDelegateEnabled() const1806 bool TestRunner::policyDelegateEnabled() const {
1807 return policy_delegate_enabled_;
1808 }
1809
policyDelegateIsPermissive() const1810 bool TestRunner::policyDelegateIsPermissive() const {
1811 return policy_delegate_is_permissive_;
1812 }
1813
policyDelegateShouldNotifyDone() const1814 bool TestRunner::policyDelegateShouldNotifyDone() const {
1815 return policy_delegate_should_notify_done_;
1816 }
1817
shouldInterceptPostMessage() const1818 bool TestRunner::shouldInterceptPostMessage() const {
1819 return intercept_post_message_;
1820 }
1821
shouldDumpResourcePriorities() const1822 bool TestRunner::shouldDumpResourcePriorities() const {
1823 return should_dump_resource_priorities_;
1824 }
1825
notification_presenter() const1826 WebNotificationPresenter* TestRunner::notification_presenter() const {
1827 return notification_presenter_.get();
1828 }
1829
RequestPointerLock()1830 bool TestRunner::RequestPointerLock() {
1831 switch (pointer_lock_planned_result_) {
1832 case PointerLockWillSucceed:
1833 delegate_->postDelayedTask(
1834 new HostMethodTask(this, &TestRunner::DidAcquirePointerLockInternal),
1835 0);
1836 return true;
1837 case PointerLockWillRespondAsync:
1838 DCHECK(!pointer_locked_);
1839 return true;
1840 case PointerLockWillFailSync:
1841 DCHECK(!pointer_locked_);
1842 return false;
1843 default:
1844 NOTREACHED();
1845 return false;
1846 }
1847 }
1848
RequestPointerUnlock()1849 void TestRunner::RequestPointerUnlock() {
1850 delegate_->postDelayedTask(
1851 new HostMethodTask(this, &TestRunner::DidLosePointerLockInternal), 0);
1852 }
1853
isPointerLocked()1854 bool TestRunner::isPointerLocked() {
1855 return pointer_locked_;
1856 }
1857
setToolTipText(const WebString & text)1858 void TestRunner::setToolTipText(const WebString& text) {
1859 tooltip_text_ = text.utf8();
1860 }
1861
midiAccessorResult()1862 bool TestRunner::midiAccessorResult() {
1863 return midi_accessor_result_;
1864 }
1865
clearDevToolsLocalStorage()1866 void TestRunner::clearDevToolsLocalStorage() {
1867 delegate_->clearDevToolsLocalStorage();
1868 }
1869
showDevTools(const std::string & settings,const std::string & frontend_url)1870 void TestRunner::showDevTools(const std::string& settings,
1871 const std::string& frontend_url) {
1872 delegate_->showDevTools(settings, frontend_url);
1873 }
1874
1875 class WorkItemBackForward : public TestRunner::WorkItem {
1876 public:
WorkItemBackForward(int distance)1877 WorkItemBackForward(int distance) : distance_(distance) {}
1878
Run(WebTestDelegate * delegate,WebView *)1879 virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
1880 delegate->goToOffset(distance_);
1881 return true; // FIXME: Did it really start a navigation?
1882 }
1883
1884 private:
1885 int distance_;
1886 };
1887
NotifyDone()1888 void TestRunner::NotifyDone() {
1889 if (disable_notify_done_)
1890 return;
1891
1892 // Test didn't timeout. Kill the timeout timer.
1893 task_list_.revokeAll();
1894
1895 CompleteNotifyDone();
1896 }
1897
WaitUntilDone()1898 void TestRunner::WaitUntilDone() {
1899 wait_until_done_ = true;
1900 }
1901
QueueBackNavigation(int how_far_back)1902 void TestRunner::QueueBackNavigation(int how_far_back) {
1903 work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
1904 }
1905
QueueForwardNavigation(int how_far_forward)1906 void TestRunner::QueueForwardNavigation(int how_far_forward) {
1907 work_queue_.AddWork(new WorkItemBackForward(how_far_forward));
1908 }
1909
1910 class WorkItemReload : public TestRunner::WorkItem {
1911 public:
Run(WebTestDelegate * delegate,WebView *)1912 virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
1913 delegate->reload();
1914 return true;
1915 }
1916 };
1917
QueueReload()1918 void TestRunner::QueueReload() {
1919 work_queue_.AddWork(new WorkItemReload());
1920 }
1921
1922 class WorkItemLoadingScript : public TestRunner::WorkItem {
1923 public:
WorkItemLoadingScript(const std::string & script)1924 WorkItemLoadingScript(const std::string& script)
1925 : script_(script) {}
1926
Run(WebTestDelegate *,WebView * web_view)1927 virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
1928 web_view->mainFrame()->executeScript(
1929 WebScriptSource(WebString::fromUTF8(script_)));
1930 return true; // FIXME: Did it really start a navigation?
1931 }
1932
1933 private:
1934 std::string script_;
1935 };
1936
QueueLoadingScript(const std::string & script)1937 void TestRunner::QueueLoadingScript(const std::string& script) {
1938 work_queue_.AddWork(new WorkItemLoadingScript(script));
1939 }
1940
1941 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
1942 public:
WorkItemNonLoadingScript(const std::string & script)1943 WorkItemNonLoadingScript(const std::string& script)
1944 : script_(script) {}
1945
Run(WebTestDelegate *,WebView * web_view)1946 virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
1947 web_view->mainFrame()->executeScript(
1948 WebScriptSource(WebString::fromUTF8(script_)));
1949 return false;
1950 }
1951
1952 private:
1953 std::string script_;
1954 };
1955
QueueNonLoadingScript(const std::string & script)1956 void TestRunner::QueueNonLoadingScript(const std::string& script) {
1957 work_queue_.AddWork(new WorkItemNonLoadingScript(script));
1958 }
1959
1960 class WorkItemLoad : public TestRunner::WorkItem {
1961 public:
WorkItemLoad(const WebURL & url,const std::string & target)1962 WorkItemLoad(const WebURL& url, const std::string& target)
1963 : url_(url), target_(target) {}
1964
Run(WebTestDelegate * delegate,WebView *)1965 virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
1966 delegate->loadURLForFrame(url_, target_);
1967 return true; // FIXME: Did it really start a navigation?
1968 }
1969
1970 private:
1971 WebURL url_;
1972 std::string target_;
1973 };
1974
QueueLoad(const std::string & url,const std::string & target)1975 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
1976 // FIXME: Implement WebURL::resolve() and avoid GURL.
1977 GURL current_url = web_view_->mainFrame()->document().url();
1978 GURL full_url = current_url.Resolve(url);
1979 work_queue_.AddWork(new WorkItemLoad(full_url, target));
1980 }
1981
1982 class WorkItemLoadHTMLString : public TestRunner::WorkItem {
1983 public:
WorkItemLoadHTMLString(const std::string & html,const WebURL & base_url)1984 WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url)
1985 : html_(html), base_url_(base_url) {}
1986
WorkItemLoadHTMLString(const std::string & html,const WebURL & base_url,const WebURL & unreachable_url)1987 WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url,
1988 const WebURL& unreachable_url)
1989 : html_(html), base_url_(base_url), unreachable_url_(unreachable_url) {}
1990
Run(WebTestDelegate *,WebView * web_view)1991 virtual bool Run(WebTestDelegate*, WebView* web_view) OVERRIDE {
1992 web_view->mainFrame()->loadHTMLString(
1993 WebData(html_.data(), html_.length()),
1994 base_url_, unreachable_url_);
1995 return true;
1996 }
1997
1998 private:
1999 std::string html_;
2000 WebURL base_url_;
2001 WebURL unreachable_url_;
2002 };
2003
QueueLoadHTMLString(gin::Arguments * args)2004 void TestRunner::QueueLoadHTMLString(gin::Arguments* args) {
2005 std::string html;
2006 args->GetNext(&html);
2007
2008 std::string base_url_str;
2009 args->GetNext(&base_url_str);
2010 WebURL base_url = WebURL(GURL(base_url_str));
2011
2012 if (args->PeekNext()->IsString()) {
2013 std::string unreachable_url_str;
2014 args->GetNext(&unreachable_url_str);
2015 WebURL unreachable_url = WebURL(GURL(unreachable_url_str));
2016 work_queue_.AddWork(new WorkItemLoadHTMLString(html, base_url,
2017 unreachable_url));
2018 } else {
2019 work_queue_.AddWork(new WorkItemLoadHTMLString(html, base_url));
2020 }
2021 }
2022
SetCustomPolicyDelegate(gin::Arguments * args)2023 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) {
2024 args->GetNext(&policy_delegate_enabled_);
2025 if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean())
2026 args->GetNext(&policy_delegate_is_permissive_);
2027 }
2028
WaitForPolicyDelegate()2029 void TestRunner::WaitForPolicyDelegate() {
2030 policy_delegate_enabled_ = true;
2031 policy_delegate_should_notify_done_ = true;
2032 wait_until_done_ = true;
2033 }
2034
WindowCount()2035 int TestRunner::WindowCount() {
2036 return test_interfaces_->windowList().size();
2037 }
2038
SetCloseRemainingWindowsWhenComplete(bool close_remaining_windows)2039 void TestRunner::SetCloseRemainingWindowsWhenComplete(
2040 bool close_remaining_windows) {
2041 close_remaining_windows_ = close_remaining_windows;
2042 }
2043
ResetTestHelperControllers()2044 void TestRunner::ResetTestHelperControllers() {
2045 test_interfaces_->resetTestHelperControllers();
2046 }
2047
SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements)2048 void TestRunner::SetTabKeyCyclesThroughElements(
2049 bool tab_key_cycles_through_elements) {
2050 web_view_->setTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
2051 }
2052
ExecCommand(gin::Arguments * args)2053 void TestRunner::ExecCommand(gin::Arguments* args) {
2054 std::string command;
2055 args->GetNext(&command);
2056
2057 std::string value;
2058 if (args->Length() >= 3) {
2059 // Ignore the second parameter (which is userInterface)
2060 // since this command emulates a manual action.
2061 args->Skip();
2062 args->GetNext(&value);
2063 }
2064
2065 // Note: webkit's version does not return the boolean, so neither do we.
2066 web_view_->focusedFrame()->executeCommand(WebString::fromUTF8(command),
2067 WebString::fromUTF8(value));
2068 }
2069
IsCommandEnabled(const std::string & command)2070 bool TestRunner::IsCommandEnabled(const std::string& command) {
2071 return web_view_->focusedFrame()->isCommandEnabled(
2072 WebString::fromUTF8(command));
2073 }
2074
CallShouldCloseOnWebView()2075 bool TestRunner::CallShouldCloseOnWebView() {
2076 return web_view_->mainFrame()->dispatchBeforeUnloadEvent();
2077 }
2078
SetDomainRelaxationForbiddenForURLScheme(bool forbidden,const std::string & scheme)2079 void TestRunner::SetDomainRelaxationForbiddenForURLScheme(
2080 bool forbidden, const std::string& scheme) {
2081 web_view_->setDomainRelaxationForbidden(forbidden,
2082 WebString::fromUTF8(scheme));
2083 }
2084
EvaluateScriptInIsolatedWorldAndReturnValue(int world_id,const std::string & script)2085 v8::Handle<v8::Value> TestRunner::EvaluateScriptInIsolatedWorldAndReturnValue(
2086 int world_id,
2087 const std::string& script) {
2088 WebVector<v8::Local<v8::Value> > values;
2089 WebScriptSource source(WebString::fromUTF8(script));
2090 // This relies on the iframe focusing itself when it loads. This is a bit
2091 // sketchy, but it seems to be what other tests do.
2092 web_view_->focusedFrame()->executeScriptInIsolatedWorld(
2093 world_id, &source, 1, 1, &values);
2094 // Since only one script was added, only one result is expected
2095 if (values.size() == 1 && !values[0].IsEmpty())
2096 return values[0];
2097 return v8::Handle<v8::Value>();
2098 }
2099
EvaluateScriptInIsolatedWorld(int world_id,const std::string & script)2100 void TestRunner::EvaluateScriptInIsolatedWorld(int world_id,
2101 const std::string& script) {
2102 WebScriptSource source(WebString::fromUTF8(script));
2103 web_view_->focusedFrame()->executeScriptInIsolatedWorld(
2104 world_id, &source, 1, 1);
2105 }
2106
SetIsolatedWorldSecurityOrigin(int world_id,v8::Handle<v8::Value> origin)2107 void TestRunner::SetIsolatedWorldSecurityOrigin(int world_id,
2108 v8::Handle<v8::Value> origin) {
2109 if (!(origin->IsString() || !origin->IsNull()))
2110 return;
2111
2112 WebSecurityOrigin web_origin;
2113 if (origin->IsString()) {
2114 web_origin = WebSecurityOrigin::createFromString(
2115 V8StringToWebString(origin->ToString()));
2116 }
2117 web_view_->focusedFrame()->setIsolatedWorldSecurityOrigin(world_id,
2118 web_origin);
2119 }
2120
SetIsolatedWorldContentSecurityPolicy(int world_id,const std::string & policy)2121 void TestRunner::SetIsolatedWorldContentSecurityPolicy(
2122 int world_id,
2123 const std::string& policy) {
2124 web_view_->focusedFrame()->setIsolatedWorldContentSecurityPolicy(
2125 world_id, WebString::fromUTF8(policy));
2126 }
2127
AddOriginAccessWhitelistEntry(const std::string & source_origin,const std::string & destination_protocol,const std::string & destination_host,bool allow_destination_subdomains)2128 void TestRunner::AddOriginAccessWhitelistEntry(
2129 const std::string& source_origin,
2130 const std::string& destination_protocol,
2131 const std::string& destination_host,
2132 bool allow_destination_subdomains) {
2133 WebURL url((GURL(source_origin)));
2134 if (!url.isValid())
2135 return;
2136
2137 WebSecurityPolicy::addOriginAccessWhitelistEntry(
2138 url,
2139 WebString::fromUTF8(destination_protocol),
2140 WebString::fromUTF8(destination_host),
2141 allow_destination_subdomains);
2142 }
2143
RemoveOriginAccessWhitelistEntry(const std::string & source_origin,const std::string & destination_protocol,const std::string & destination_host,bool allow_destination_subdomains)2144 void TestRunner::RemoveOriginAccessWhitelistEntry(
2145 const std::string& source_origin,
2146 const std::string& destination_protocol,
2147 const std::string& destination_host,
2148 bool allow_destination_subdomains) {
2149 WebURL url((GURL(source_origin)));
2150 if (!url.isValid())
2151 return;
2152
2153 WebSecurityPolicy::removeOriginAccessWhitelistEntry(
2154 url,
2155 WebString::fromUTF8(destination_protocol),
2156 WebString::fromUTF8(destination_host),
2157 allow_destination_subdomains);
2158 }
2159
HasCustomPageSizeStyle(int page_index)2160 bool TestRunner::HasCustomPageSizeStyle(int page_index) {
2161 WebFrame* frame = web_view_->mainFrame();
2162 if (!frame)
2163 return false;
2164 return frame->hasCustomPageSizeStyle(page_index);
2165 }
2166
ForceRedSelectionColors()2167 void TestRunner::ForceRedSelectionColors() {
2168 web_view_->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
2169 }
2170
InjectStyleSheet(const std::string & source_code,bool all_frames)2171 void TestRunner::InjectStyleSheet(const std::string& source_code,
2172 bool all_frames) {
2173 WebView::injectStyleSheet(
2174 WebString::fromUTF8(source_code),
2175 WebVector<WebString>(),
2176 all_frames ? WebView::InjectStyleInAllFrames
2177 : WebView::InjectStyleInTopFrameOnly);
2178 }
2179
FindString(const std::string & search_text,const std::vector<std::string> & options_array)2180 bool TestRunner::FindString(const std::string& search_text,
2181 const std::vector<std::string>& options_array) {
2182 WebFindOptions find_options;
2183 bool wrap_around = false;
2184 find_options.matchCase = true;
2185 find_options.findNext = true;
2186
2187 for (size_t i = 0; i < options_array.size(); ++i) {
2188 const std::string& option = options_array[i];
2189 if (option == "CaseInsensitive")
2190 find_options.matchCase = false;
2191 else if (option == "Backwards")
2192 find_options.forward = false;
2193 else if (option == "StartInSelection")
2194 find_options.findNext = false;
2195 else if (option == "AtWordStarts")
2196 find_options.wordStart = true;
2197 else if (option == "TreatMedialCapitalAsWordStart")
2198 find_options.medialCapitalAsWordStart = true;
2199 else if (option == "WrapAround")
2200 wrap_around = true;
2201 }
2202
2203 WebFrame* frame = web_view_->mainFrame();
2204 const bool find_result = frame->find(0, WebString::fromUTF8(search_text),
2205 find_options, wrap_around, 0);
2206 frame->stopFinding(false);
2207 return find_result;
2208 }
2209
SelectionAsMarkup()2210 std::string TestRunner::SelectionAsMarkup() {
2211 return web_view_->mainFrame()->selectionAsMarkup().utf8();
2212 }
2213
SetTextSubpixelPositioning(bool value)2214 void TestRunner::SetTextSubpixelPositioning(bool value) {
2215 #if defined(__linux__) || defined(ANDROID)
2216 // Since FontConfig doesn't provide a variable to control subpixel
2217 // positioning, we'll fall back to setting it globally for all fonts.
2218 WebFontRendering::setSubpixelPositioning(value);
2219 #endif
2220 }
2221
SetPageVisibility(const std::string & new_visibility)2222 void TestRunner::SetPageVisibility(const std::string& new_visibility) {
2223 if (new_visibility == "visible")
2224 web_view_->setVisibilityState(WebPageVisibilityStateVisible, false);
2225 else if (new_visibility == "hidden")
2226 web_view_->setVisibilityState(WebPageVisibilityStateHidden, false);
2227 else if (new_visibility == "prerender")
2228 web_view_->setVisibilityState(WebPageVisibilityStatePrerender, false);
2229 }
2230
SetTextDirection(const std::string & direction_name)2231 void TestRunner::SetTextDirection(const std::string& direction_name) {
2232 // Map a direction name to a WebTextDirection value.
2233 WebTextDirection direction;
2234 if (direction_name == "auto")
2235 direction = WebTextDirectionDefault;
2236 else if (direction_name == "rtl")
2237 direction = WebTextDirectionRightToLeft;
2238 else if (direction_name == "ltr")
2239 direction = WebTextDirectionLeftToRight;
2240 else
2241 return;
2242
2243 web_view_->setTextDirection(direction);
2244 }
2245
UseUnfortunateSynchronousResizeMode()2246 void TestRunner::UseUnfortunateSynchronousResizeMode() {
2247 delegate_->useUnfortunateSynchronousResizeMode(true);
2248 }
2249
EnableAutoResizeMode(int min_width,int min_height,int max_width,int max_height)2250 bool TestRunner::EnableAutoResizeMode(int min_width,
2251 int min_height,
2252 int max_width,
2253 int max_height) {
2254 WebSize min_size(min_width, min_height);
2255 WebSize max_size(max_width, max_height);
2256 delegate_->enableAutoResizeMode(min_size, max_size);
2257 return true;
2258 }
2259
DisableAutoResizeMode(int new_width,int new_height)2260 bool TestRunner::DisableAutoResizeMode(int new_width, int new_height) {
2261 WebSize new_size(new_width, new_height);
2262 delegate_->disableAutoResizeMode(new_size);
2263 return true;
2264 }
2265
SetMockDeviceMotion(bool has_acceleration_x,double acceleration_x,bool has_acceleration_y,double acceleration_y,bool has_acceleration_z,double acceleration_z,bool has_acceleration_including_gravity_x,double acceleration_including_gravity_x,bool has_acceleration_including_gravity_y,double acceleration_including_gravity_y,bool has_acceleration_including_gravity_z,double acceleration_including_gravity_z,bool has_rotation_rate_alpha,double rotation_rate_alpha,bool has_rotation_rate_beta,double rotation_rate_beta,bool has_rotation_rate_gamma,double rotation_rate_gamma,double interval)2266 void TestRunner::SetMockDeviceMotion(
2267 bool has_acceleration_x, double acceleration_x,
2268 bool has_acceleration_y, double acceleration_y,
2269 bool has_acceleration_z, double acceleration_z,
2270 bool has_acceleration_including_gravity_x,
2271 double acceleration_including_gravity_x,
2272 bool has_acceleration_including_gravity_y,
2273 double acceleration_including_gravity_y,
2274 bool has_acceleration_including_gravity_z,
2275 double acceleration_including_gravity_z,
2276 bool has_rotation_rate_alpha, double rotation_rate_alpha,
2277 bool has_rotation_rate_beta, double rotation_rate_beta,
2278 bool has_rotation_rate_gamma, double rotation_rate_gamma,
2279 double interval) {
2280 WebDeviceMotionData motion;
2281
2282 // acceleration
2283 motion.hasAccelerationX = has_acceleration_x;
2284 motion.accelerationX = acceleration_x;
2285 motion.hasAccelerationY = has_acceleration_y;
2286 motion.accelerationY = acceleration_y;
2287 motion.hasAccelerationZ = has_acceleration_z;
2288 motion.accelerationZ = acceleration_z;
2289
2290 // accelerationIncludingGravity
2291 motion.hasAccelerationIncludingGravityX =
2292 has_acceleration_including_gravity_x;
2293 motion.accelerationIncludingGravityX = acceleration_including_gravity_x;
2294 motion.hasAccelerationIncludingGravityY =
2295 has_acceleration_including_gravity_y;
2296 motion.accelerationIncludingGravityY = acceleration_including_gravity_y;
2297 motion.hasAccelerationIncludingGravityZ =
2298 has_acceleration_including_gravity_z;
2299 motion.accelerationIncludingGravityZ = acceleration_including_gravity_z;
2300
2301 // rotationRate
2302 motion.hasRotationRateAlpha = has_rotation_rate_alpha;
2303 motion.rotationRateAlpha = rotation_rate_alpha;
2304 motion.hasRotationRateBeta = has_rotation_rate_beta;
2305 motion.rotationRateBeta = rotation_rate_beta;
2306 motion.hasRotationRateGamma = has_rotation_rate_gamma;
2307 motion.rotationRateGamma = rotation_rate_gamma;
2308
2309 // interval
2310 motion.interval = interval;
2311
2312 delegate_->setDeviceMotionData(motion);
2313 }
2314
SetMockDeviceOrientation(bool has_alpha,double alpha,bool has_beta,double beta,bool has_gamma,double gamma,bool has_absolute,bool absolute)2315 void TestRunner::SetMockDeviceOrientation(bool has_alpha, double alpha,
2316 bool has_beta, double beta,
2317 bool has_gamma, double gamma,
2318 bool has_absolute, bool absolute) {
2319 WebDeviceOrientationData orientation;
2320
2321 // alpha
2322 orientation.hasAlpha = has_alpha;
2323 orientation.alpha = alpha;
2324
2325 // beta
2326 orientation.hasBeta = has_beta;
2327 orientation.beta = beta;
2328
2329 // gamma
2330 orientation.hasGamma = has_gamma;
2331 orientation.gamma = gamma;
2332
2333 // absolute
2334 orientation.hasAbsolute = has_absolute;
2335 orientation.absolute = absolute;
2336
2337 delegate_->setDeviceOrientationData(orientation);
2338 }
2339
SetMockScreenOrientation(const std::string & orientation_str)2340 void TestRunner::SetMockScreenOrientation(const std::string& orientation_str) {
2341 blink::WebScreenOrientationType orientation;
2342
2343 if (orientation_str == "portrait-primary") {
2344 orientation = WebScreenOrientationPortraitPrimary;
2345 } else if (orientation_str == "portrait-secondary") {
2346 orientation = WebScreenOrientationPortraitSecondary;
2347 } else if (orientation_str == "landscape-primary") {
2348 orientation = WebScreenOrientationLandscapePrimary;
2349 } else if (orientation_str == "landscape-secondary") {
2350 orientation = WebScreenOrientationLandscapeSecondary;
2351 }
2352
2353 delegate_->setScreenOrientation(orientation);
2354 }
2355
DidChangeBatteryStatus(bool charging,double chargingTime,double dischargingTime,double level)2356 void TestRunner::DidChangeBatteryStatus(bool charging,
2357 double chargingTime,
2358 double dischargingTime,
2359 double level) {
2360 blink::WebBatteryStatus status;
2361 status.charging = charging;
2362 status.chargingTime = chargingTime;
2363 status.dischargingTime = dischargingTime;
2364 status.level = level;
2365 delegate_->didChangeBatteryStatus(status);
2366 }
2367
ResetBatteryStatus()2368 void TestRunner::ResetBatteryStatus() {
2369 blink::WebBatteryStatus status;
2370 delegate_->didChangeBatteryStatus(status);
2371 }
2372
DidAcquirePointerLock()2373 void TestRunner::DidAcquirePointerLock() {
2374 DidAcquirePointerLockInternal();
2375 }
2376
DidNotAcquirePointerLock()2377 void TestRunner::DidNotAcquirePointerLock() {
2378 DidNotAcquirePointerLockInternal();
2379 }
2380
DidLosePointerLock()2381 void TestRunner::DidLosePointerLock() {
2382 DidLosePointerLockInternal();
2383 }
2384
SetPointerLockWillFailSynchronously()2385 void TestRunner::SetPointerLockWillFailSynchronously() {
2386 pointer_lock_planned_result_ = PointerLockWillFailSync;
2387 }
2388
SetPointerLockWillRespondAsynchronously()2389 void TestRunner::SetPointerLockWillRespondAsynchronously() {
2390 pointer_lock_planned_result_ = PointerLockWillRespondAsync;
2391 }
2392
SetPopupBlockingEnabled(bool block_popups)2393 void TestRunner::SetPopupBlockingEnabled(bool block_popups) {
2394 delegate_->preferences()->java_script_can_open_windows_automatically =
2395 !block_popups;
2396 delegate_->applyPreferences();
2397 }
2398
SetJavaScriptCanAccessClipboard(bool can_access)2399 void TestRunner::SetJavaScriptCanAccessClipboard(bool can_access) {
2400 delegate_->preferences()->java_script_can_access_clipboard = can_access;
2401 delegate_->applyPreferences();
2402 }
2403
SetXSSAuditorEnabled(bool enabled)2404 void TestRunner::SetXSSAuditorEnabled(bool enabled) {
2405 delegate_->preferences()->xss_auditor_enabled = enabled;
2406 delegate_->applyPreferences();
2407 }
2408
SetAllowUniversalAccessFromFileURLs(bool allow)2409 void TestRunner::SetAllowUniversalAccessFromFileURLs(bool allow) {
2410 delegate_->preferences()->allow_universal_access_from_file_urls = allow;
2411 delegate_->applyPreferences();
2412 }
2413
SetAllowFileAccessFromFileURLs(bool allow)2414 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) {
2415 delegate_->preferences()->allow_file_access_from_file_urls = allow;
2416 delegate_->applyPreferences();
2417 }
2418
OverridePreference(const std::string key,v8::Handle<v8::Value> value)2419 void TestRunner::OverridePreference(const std::string key,
2420 v8::Handle<v8::Value> value) {
2421 TestPreferences* prefs = delegate_->preferences();
2422 if (key == "WebKitDefaultFontSize") {
2423 prefs->default_font_size = value->Int32Value();
2424 } else if (key == "WebKitMinimumFontSize") {
2425 prefs->minimum_font_size = value->Int32Value();
2426 } else if (key == "WebKitDefaultTextEncodingName") {
2427 prefs->default_text_encoding_name = V8StringToWebString(value->ToString());
2428 } else if (key == "WebKitJavaScriptEnabled") {
2429 prefs->java_script_enabled = value->BooleanValue();
2430 } else if (key == "WebKitSupportsMultipleWindows") {
2431 prefs->supports_multiple_windows = value->BooleanValue();
2432 } else if (key == "WebKitDisplayImagesKey") {
2433 prefs->loads_images_automatically = value->BooleanValue();
2434 } else if (key == "WebKitPluginsEnabled") {
2435 prefs->plugins_enabled = value->BooleanValue();
2436 } else if (key == "WebKitJavaEnabled") {
2437 prefs->java_enabled = value->BooleanValue();
2438 } else if (key == "WebKitOfflineWebApplicationCacheEnabled") {
2439 prefs->offline_web_application_cache_enabled = value->BooleanValue();
2440 } else if (key == "WebKitTabToLinksPreferenceKey") {
2441 prefs->tabs_to_links = value->BooleanValue();
2442 } else if (key == "WebKitWebGLEnabled") {
2443 prefs->experimental_webgl_enabled = value->BooleanValue();
2444 } else if (key == "WebKitCSSRegionsEnabled") {
2445 prefs->experimental_css_regions_enabled = value->BooleanValue();
2446 } else if (key == "WebKitCSSGridLayoutEnabled") {
2447 prefs->experimental_css_grid_layout_enabled = value->BooleanValue();
2448 } else if (key == "WebKitHyperlinkAuditingEnabled") {
2449 prefs->hyperlink_auditing_enabled = value->BooleanValue();
2450 } else if (key == "WebKitEnableCaretBrowsing") {
2451 prefs->caret_browsing_enabled = value->BooleanValue();
2452 } else if (key == "WebKitAllowDisplayingInsecureContent") {
2453 prefs->allow_display_of_insecure_content = value->BooleanValue();
2454 } else if (key == "WebKitAllowRunningInsecureContent") {
2455 prefs->allow_running_of_insecure_content = value->BooleanValue();
2456 } else if (key == "WebKitShouldRespectImageOrientation") {
2457 prefs->should_respect_image_orientation = value->BooleanValue();
2458 } else if (key == "WebKitWebAudioEnabled") {
2459 DCHECK(value->BooleanValue());
2460 } else {
2461 std::string message("Invalid name for preference: ");
2462 message.append(key);
2463 delegate_->printMessage(std::string("CONSOLE MESSAGE: ") + message + "\n");
2464 }
2465 delegate_->applyPreferences();
2466 }
2467
SetAcceptLanguages(const std::string & accept_languages)2468 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) {
2469 proxy_->SetAcceptLanguages(accept_languages);
2470 }
2471
SetPluginsEnabled(bool enabled)2472 void TestRunner::SetPluginsEnabled(bool enabled) {
2473 delegate_->preferences()->plugins_enabled = enabled;
2474 delegate_->applyPreferences();
2475 }
2476
DumpEditingCallbacks()2477 void TestRunner::DumpEditingCallbacks() {
2478 dump_editting_callbacks_ = true;
2479 }
2480
DumpAsMarkup()2481 void TestRunner::DumpAsMarkup() {
2482 dump_as_markup_ = true;
2483 generate_pixel_results_ = false;
2484 }
2485
DumpAsText()2486 void TestRunner::DumpAsText() {
2487 dump_as_text_ = true;
2488 generate_pixel_results_ = false;
2489 }
2490
DumpAsTextWithPixelResults()2491 void TestRunner::DumpAsTextWithPixelResults() {
2492 dump_as_text_ = true;
2493 generate_pixel_results_ = true;
2494 }
2495
DumpChildFrameScrollPositions()2496 void TestRunner::DumpChildFrameScrollPositions() {
2497 dump_child_frame_scroll_positions_ = true;
2498 }
2499
DumpChildFramesAsMarkup()2500 void TestRunner::DumpChildFramesAsMarkup() {
2501 dump_child_frames_as_markup_ = true;
2502 }
2503
DumpChildFramesAsText()2504 void TestRunner::DumpChildFramesAsText() {
2505 dump_child_frames_as_text_ = true;
2506 }
2507
DumpIconChanges()2508 void TestRunner::DumpIconChanges() {
2509 dump_icon_changes_ = true;
2510 }
2511
SetAudioData(const gin::ArrayBufferView & view)2512 void TestRunner::SetAudioData(const gin::ArrayBufferView& view) {
2513 unsigned char* bytes = static_cast<unsigned char*>(view.bytes());
2514 audio_data_.resize(view.num_bytes());
2515 std::copy(bytes, bytes + view.num_bytes(), audio_data_.begin());
2516 dump_as_audio_ = true;
2517 }
2518
DumpFrameLoadCallbacks()2519 void TestRunner::DumpFrameLoadCallbacks() {
2520 dump_frame_load_callbacks_ = true;
2521 }
2522
DumpPingLoaderCallbacks()2523 void TestRunner::DumpPingLoaderCallbacks() {
2524 dump_ping_loader_callbacks_ = true;
2525 }
2526
DumpUserGestureInFrameLoadCallbacks()2527 void TestRunner::DumpUserGestureInFrameLoadCallbacks() {
2528 dump_user_gesture_in_frame_load_callbacks_ = true;
2529 }
2530
DumpTitleChanges()2531 void TestRunner::DumpTitleChanges() {
2532 dump_title_changes_ = true;
2533 }
2534
DumpCreateView()2535 void TestRunner::DumpCreateView() {
2536 dump_create_view_ = true;
2537 }
2538
SetCanOpenWindows()2539 void TestRunner::SetCanOpenWindows() {
2540 can_open_windows_ = true;
2541 }
2542
DumpResourceLoadCallbacks()2543 void TestRunner::DumpResourceLoadCallbacks() {
2544 dump_resource_load_callbacks_ = true;
2545 }
2546
DumpResourceRequestCallbacks()2547 void TestRunner::DumpResourceRequestCallbacks() {
2548 dump_resource_request_callbacks_ = true;
2549 }
2550
DumpResourceResponseMIMETypes()2551 void TestRunner::DumpResourceResponseMIMETypes() {
2552 dump_resource_reqponse_mime_types_ = true;
2553 }
2554
SetImagesAllowed(bool allowed)2555 void TestRunner::SetImagesAllowed(bool allowed) {
2556 web_permissions_->SetImagesAllowed(allowed);
2557 }
2558
SetMediaAllowed(bool allowed)2559 void TestRunner::SetMediaAllowed(bool allowed) {
2560 web_permissions_->SetMediaAllowed(allowed);
2561 }
2562
SetScriptsAllowed(bool allowed)2563 void TestRunner::SetScriptsAllowed(bool allowed) {
2564 web_permissions_->SetScriptsAllowed(allowed);
2565 }
2566
SetStorageAllowed(bool allowed)2567 void TestRunner::SetStorageAllowed(bool allowed) {
2568 web_permissions_->SetStorageAllowed(allowed);
2569 }
2570
SetPluginsAllowed(bool allowed)2571 void TestRunner::SetPluginsAllowed(bool allowed) {
2572 web_permissions_->SetPluginsAllowed(allowed);
2573 }
2574
SetAllowDisplayOfInsecureContent(bool allowed)2575 void TestRunner::SetAllowDisplayOfInsecureContent(bool allowed) {
2576 web_permissions_->SetDisplayingInsecureContentAllowed(allowed);
2577 }
2578
SetAllowRunningOfInsecureContent(bool allowed)2579 void TestRunner::SetAllowRunningOfInsecureContent(bool allowed) {
2580 web_permissions_->SetRunningInsecureContentAllowed(allowed);
2581 }
2582
DumpPermissionClientCallbacks()2583 void TestRunner::DumpPermissionClientCallbacks() {
2584 web_permissions_->SetDumpCallbacks(true);
2585 }
2586
DumpWindowStatusChanges()2587 void TestRunner::DumpWindowStatusChanges() {
2588 dump_window_status_changes_ = true;
2589 }
2590
DumpProgressFinishedCallback()2591 void TestRunner::DumpProgressFinishedCallback() {
2592 dump_progress_finished_callback_ = true;
2593 }
2594
DumpSpellCheckCallbacks()2595 void TestRunner::DumpSpellCheckCallbacks() {
2596 dump_spell_check_callbacks_ = true;
2597 }
2598
DumpBackForwardList()2599 void TestRunner::DumpBackForwardList() {
2600 dump_back_forward_list_ = true;
2601 }
2602
DumpSelectionRect()2603 void TestRunner::DumpSelectionRect() {
2604 dump_selection_rect_ = true;
2605 }
2606
SetPrinting()2607 void TestRunner::SetPrinting() {
2608 is_printing_ = true;
2609 }
2610
SetShouldStayOnPageAfterHandlingBeforeUnload(bool value)2611 void TestRunner::SetShouldStayOnPageAfterHandlingBeforeUnload(bool value) {
2612 should_stay_on_page_after_handling_before_unload_ = value;
2613 }
2614
SetWillSendRequestClearHeader(const std::string & header)2615 void TestRunner::SetWillSendRequestClearHeader(const std::string& header) {
2616 if (!header.empty())
2617 http_headers_to_clear_.insert(header);
2618 }
2619
DumpResourceRequestPriorities()2620 void TestRunner::DumpResourceRequestPriorities() {
2621 should_dump_resource_priorities_ = true;
2622 }
2623
SetUseMockTheme(bool use)2624 void TestRunner::SetUseMockTheme(bool use) {
2625 use_mock_theme_ = use;
2626 }
2627
ShowWebInspector(const std::string & str,const std::string & frontend_url)2628 void TestRunner::ShowWebInspector(const std::string& str,
2629 const std::string& frontend_url) {
2630 showDevTools(str, frontend_url);
2631 }
2632
WaitUntilExternalURLLoad()2633 void TestRunner::WaitUntilExternalURLLoad() {
2634 wait_until_external_url_load_ = true;
2635 }
2636
CloseWebInspector()2637 void TestRunner::CloseWebInspector() {
2638 delegate_->closeDevTools();
2639 }
2640
IsChooserShown()2641 bool TestRunner::IsChooserShown() {
2642 return proxy_->IsChooserShown();
2643 }
2644
EvaluateInWebInspector(int call_id,const std::string & script)2645 void TestRunner::EvaluateInWebInspector(int call_id,
2646 const std::string& script) {
2647 delegate_->evaluateInWebInspector(call_id, script);
2648 }
2649
ClearAllDatabases()2650 void TestRunner::ClearAllDatabases() {
2651 delegate_->clearAllDatabases();
2652 }
2653
SetDatabaseQuota(int quota)2654 void TestRunner::SetDatabaseQuota(int quota) {
2655 delegate_->setDatabaseQuota(quota);
2656 }
2657
SetAlwaysAcceptCookies(bool accept)2658 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
2659 delegate_->setAcceptAllCookies(accept);
2660 }
2661
SetWindowIsKey(bool value)2662 void TestRunner::SetWindowIsKey(bool value) {
2663 delegate_->setFocus(proxy_, value);
2664 }
2665
PathToLocalResource(const std::string & path)2666 std::string TestRunner::PathToLocalResource(const std::string& path) {
2667 return delegate_->pathToLocalResource(path);
2668 }
2669
SetBackingScaleFactor(double value,v8::Handle<v8::Function> callback)2670 void TestRunner::SetBackingScaleFactor(double value,
2671 v8::Handle<v8::Function> callback) {
2672 delegate_->setDeviceScaleFactor(value);
2673 delegate_->postTask(new InvokeCallbackTask(this, callback));
2674 }
2675
SetColorProfile(const std::string & name,v8::Handle<v8::Function> callback)2676 void TestRunner::SetColorProfile(const std::string& name,
2677 v8::Handle<v8::Function> callback) {
2678 delegate_->setDeviceColorProfile(name);
2679 delegate_->postTask(new InvokeCallbackTask(this, callback));
2680 }
2681
SetPOSIXLocale(const std::string & locale)2682 void TestRunner::SetPOSIXLocale(const std::string& locale) {
2683 delegate_->setLocale(locale);
2684 }
2685
SetMIDIAccessorResult(bool result)2686 void TestRunner::SetMIDIAccessorResult(bool result) {
2687 midi_accessor_result_ = result;
2688 }
2689
SetMIDISysexPermission(bool value)2690 void TestRunner::SetMIDISysexPermission(bool value) {
2691 const std::vector<WebTestProxyBase*>& windowList =
2692 test_interfaces_->windowList();
2693 for (unsigned i = 0; i < windowList.size(); ++i)
2694 windowList.at(i)->GetMIDIClientMock()->setSysexPermission(value);
2695 }
2696
GrantWebNotificationPermission(const std::string & origin,bool permission_granted)2697 void TestRunner::GrantWebNotificationPermission(const std::string& origin,
2698 bool permission_granted) {
2699 notification_presenter_->GrantPermission(origin, permission_granted);
2700 }
2701
SimulateWebNotificationClick(const std::string & value)2702 bool TestRunner::SimulateWebNotificationClick(const std::string& value) {
2703 return notification_presenter_->SimulateClick(value);
2704 }
2705
AddMockSpeechRecognitionResult(const std::string & transcript,double confidence)2706 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript,
2707 double confidence) {
2708 proxy_->GetSpeechRecognizerMock()->addMockResult(
2709 WebString::fromUTF8(transcript), confidence);
2710 }
2711
SetMockSpeechRecognitionError(const std::string & error,const std::string & message)2712 void TestRunner::SetMockSpeechRecognitionError(const std::string& error,
2713 const std::string& message) {
2714 proxy_->GetSpeechRecognizerMock()->setError(WebString::fromUTF8(error),
2715 WebString::fromUTF8(message));
2716 }
2717
WasMockSpeechRecognitionAborted()2718 bool TestRunner::WasMockSpeechRecognitionAborted() {
2719 return proxy_->GetSpeechRecognizerMock()->wasAborted();
2720 }
2721
AddWebPageOverlay()2722 void TestRunner::AddWebPageOverlay() {
2723 if (web_view_ && !page_overlay_) {
2724 page_overlay_ = new TestPageOverlay(web_view_);
2725 web_view_->addPageOverlay(page_overlay_, 0);
2726 }
2727 }
2728
RemoveWebPageOverlay()2729 void TestRunner::RemoveWebPageOverlay() {
2730 if (web_view_ && page_overlay_) {
2731 web_view_->removePageOverlay(page_overlay_);
2732 delete page_overlay_;
2733 page_overlay_ = NULL;
2734 }
2735 }
2736
DisplayAsync()2737 void TestRunner::DisplayAsync() {
2738 proxy_->DisplayAsyncThen(base::Closure());
2739 }
2740
DisplayAsyncThen(v8::Handle<v8::Function> callback)2741 void TestRunner::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
2742 scoped_ptr<InvokeCallbackTask> task(
2743 new InvokeCallbackTask(this, callback));
2744 proxy_->DisplayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
2745 base::Unretained(this),
2746 base::Passed(&task)));
2747 }
2748
CapturePixelsAsyncThen(v8::Handle<v8::Function> callback)2749 void TestRunner::CapturePixelsAsyncThen(v8::Handle<v8::Function> callback) {
2750 scoped_ptr<InvokeCallbackTask> task(
2751 new InvokeCallbackTask(this, callback));
2752 proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
2753 base::Unretained(this),
2754 base::Passed(&task)));
2755 }
2756
CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,const SkBitmap & snapshot)2757 void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
2758 const SkBitmap& snapshot) {
2759 v8::Isolate* isolate = blink::mainThreadIsolate();
2760 v8::HandleScope handle_scope(isolate);
2761
2762 v8::Handle<v8::Context> context =
2763 web_view_->mainFrame()->mainWorldScriptContext();
2764 if (context.IsEmpty())
2765 return;
2766
2767 v8::Context::Scope context_scope(context);
2768 v8::Handle<v8::Value> argv[3];
2769 SkAutoLockPixels snapshot_lock(snapshot);
2770
2771 int width = snapshot.info().fWidth;
2772 DCHECK_NE(0, width);
2773 argv[0] = v8::Number::New(isolate, width);
2774
2775 int height = snapshot.info().fHeight;
2776 DCHECK_NE(0, height);
2777 argv[1] = v8::Number::New(isolate, height);
2778
2779 blink::WebArrayBuffer buffer =
2780 blink::WebArrayBuffer::create(snapshot.getSize(), 1);
2781 memcpy(buffer.data(), snapshot.getPixels(), buffer.byteLength());
2782 argv[2] = blink::WebArrayBufferConverter::toV8Value(
2783 &buffer, context->Global(), isolate);
2784
2785 task->SetArguments(3, argv);
2786 InvokeCallback(task.Pass());
2787 }
2788
SetMockPushClientSuccess(const std::string & end_point,const std::string & registration_id)2789 void TestRunner::SetMockPushClientSuccess(
2790 const std::string& end_point, const std::string& registration_id) {
2791 proxy_->GetPushClientMock()->SetMockSuccessValues(end_point, registration_id);
2792 }
2793
SetMockPushClientError(const std::string & message)2794 void TestRunner::SetMockPushClientError(const std::string& message) {
2795 proxy_->GetPushClientMock()->SetMockErrorValues(message);
2796 }
2797
LocationChangeDone()2798 void TestRunner::LocationChangeDone() {
2799 web_history_item_count_ = delegate_->navigationEntryCount();
2800
2801 // No more new work after the first complete load.
2802 work_queue_.set_frozen(true);
2803
2804 if (!wait_until_done_)
2805 work_queue_.ProcessWorkSoon();
2806 }
2807
CheckResponseMimeType()2808 void TestRunner::CheckResponseMimeType() {
2809 // Text output: the test page can request different types of output which we
2810 // handle here.
2811 if (!dump_as_text_) {
2812 std::string mimeType =
2813 web_view_->mainFrame()->dataSource()->response().mimeType().utf8();
2814 if (mimeType == "text/plain") {
2815 dump_as_text_ = true;
2816 generate_pixel_results_ = false;
2817 }
2818 }
2819 }
2820
CompleteNotifyDone()2821 void TestRunner::CompleteNotifyDone() {
2822 if (wait_until_done_ && !topLoadingFrame() && work_queue_.is_empty())
2823 delegate_->testFinished();
2824 wait_until_done_ = false;
2825 }
2826
DidAcquirePointerLockInternal()2827 void TestRunner::DidAcquirePointerLockInternal() {
2828 pointer_locked_ = true;
2829 web_view_->didAcquirePointerLock();
2830
2831 // Reset planned result to default.
2832 pointer_lock_planned_result_ = PointerLockWillSucceed;
2833 }
2834
DidNotAcquirePointerLockInternal()2835 void TestRunner::DidNotAcquirePointerLockInternal() {
2836 DCHECK(!pointer_locked_);
2837 pointer_locked_ = false;
2838 web_view_->didNotAcquirePointerLock();
2839
2840 // Reset planned result to default.
2841 pointer_lock_planned_result_ = PointerLockWillSucceed;
2842 }
2843
DidLosePointerLockInternal()2844 void TestRunner::DidLosePointerLockInternal() {
2845 bool was_locked = pointer_locked_;
2846 pointer_locked_ = false;
2847 if (was_locked)
2848 web_view_->didLosePointerLock();
2849 }
2850
2851 } // namespace content
2852