Source/WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.cpp

   1 /*
   2     Copyright (C) 2010 Robert Hogan <robert@roberthogan.net>
   3     Copyright (C) 2008,2009,2010 Nokia Corporation and/or its subsidiary(-ies)
   4     Copyright (C) 2007 Staikos Computing Services Inc.
   5     Copyright (C) 2007 Apple Inc.
   6
   7     This library is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Library General Public
   9     License as published by the Free Software Foundation; either
  10     version 2 of the License, or (at your option) any later version.
  11
  12     This library is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Library General Public License for more details.
  16
  17     You should have received a copy of the GNU Library General Public License
  18     along with this library; see the file COPYING.LIB.  If not, write to
  19     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20     Boston, MA 02110-1301, USA.
  21 */
  22
  23 #include "config.h"
  24 #include "DumpRenderTreeSupportQt.h"
  25
  26 #include "ApplicationCacheStorage.h"
  27 #include "CSSComputedStyleDeclaration.h"
  28 #include "ChromeClientQt.h"
  29 #include "ContainerNode.h"
  30 #include "ContextMenu.h"
  31 #include "ContextMenuClientQt.h"
  32 #include "ContextMenuController.h"
  33 #include "DeviceOrientation.h"
  34 #include "DeviceOrientationClientMockQt.h"
  35 #include "DocumentLoader.h"
  36 #include "Editor.h"
  37 #include "EditorClientQt.h"
  38 #include "Element.h"
  39 #include "FocusController.h"
  40 #include "Frame.h"
  41 #include "FrameLoaderClientQt.h"
  42 #include "FrameView.h"
  43 #if USE(JSC)
  44 #include "GCController.h"
  45 #elif USE(V8)
  46 #include "V8GCController.h"
  47 #include "V8Proxy.h"
  48 #endif
  49 #include "GeolocationClient.h"
  50 #include "GeolocationClientMock.h"
  51 #include "GeolocationController.h"
  52 #include "GeolocationError.h"
  53 #include "GeolocationPosition.h"
  54 #include "HistoryItem.h"
  55 #include "HTMLInputElement.h"
  56 #include "InspectorController.h"
  57 #include "NodeList.h"
  58 #include "NotificationPresenterClientQt.h"
  59 #include "Page.h"
  60 #include "PageGroup.h"
  61 #include "PluginDatabase.h"
  62 #include "PositionError.h"
  63 #include "PrintContext.h"
  64 #include "RenderListItem.h"
  65 #include "RenderTreeAsText.h"
  66 #include "ScriptController.h"
  67 #include "SecurityOrigin.h"
  68 #include "Settings.h"
  69 #if ENABLE(SVG)
  70 #include "SVGDocumentExtensions.h"
  71 #include "SVGSMILElement.h"
  72 #endif
  73 #include "TextIterator.h"
  74 #include "WorkerThread.h"
  75 #include <wtf/CurrentTime.h>
  76
  77 #include "qwebelement.h"
  78 #include "qwebframe.h"
  79 #include "qwebframe_p.h"
  80 #include "qwebhistory.h"
  81 #include "qwebhistory_p.h"
  82 #include "qwebpage.h"
  83 #include "qwebpage_p.h"
  84 #include "qwebscriptworld.h"
  85
  86 #if ENABLE(VIDEO) && USE(QT_MULTIMEDIA)
  87 #include "HTMLVideoElement.h"
  88 #include "MediaPlayerPrivateQt.h"
  89 #endif
  90
  91 using namespace WebCore;
  92
  93 QMap<int, QWebScriptWorld*> m_worldMap;
  94
  95 #if ENABLE(CLIENT_BASED_GEOLOCATION)
  96 GeolocationClientMock* toGeolocationClientMock(GeolocationClient* client)
  97 {
  98      ASSERT(QWebPagePrivate::drtRun);
  99      return static_cast<GeolocationClientMock*>(client);
 100 }
 101 #endif
 102
 103 QDRTNode::QDRTNode()
 104     : m_node(0)
 105 {
 106 }
 107
 108 QDRTNode::QDRTNode(WebCore::Node* node)
 109     : m_node(0)
 110 {
 111     if (node) {
 112         m_node = node;
 113         m_node->ref();
 114     }
 115 }
 116
 117 QDRTNode::~QDRTNode()
 118 {
 119     if (m_node)
 120         m_node->deref();
 121 }
 122
 123 QDRTNode::QDRTNode(const QDRTNode& other)
 124     :m_node(other.m_node)
 125 {
 126     if (m_node)
 127         m_node->ref();
 128 }
 129
 130 QDRTNode& QDRTNode::operator=(const QDRTNode& other)
 131 {
 132     if (this != &other) {
 133         Node* otherNode = other.m_node;
 134         if (otherNode)
 135             otherNode->ref();
 136         if (m_node)
 137             m_node->deref();
 138         m_node = otherNode;
 139     }
 140     return *this;
 141 }
 142
 143
 144 DumpRenderTreeSupportQt::DumpRenderTreeSupportQt()
 145 {
 146 }
 147
 148 DumpRenderTreeSupportQt::~DumpRenderTreeSupportQt()
 149 {
 150 }
 151
 152 void DumpRenderTreeSupportQt::overwritePluginDirectories()
 153 {
 154     PluginDatabase* db = PluginDatabase::installedPlugins(/* populate */ false);
 155
 156     Vector<String> paths;
 157     String qtPath(qgetenv("QTWEBKIT_PLUGIN_PATH").data());
 158     qtPath.split(UChar(':'), /* allowEmptyEntries */ false, paths);
 159
 160     db->setPluginDirectories(paths);
 161     db->refresh();
 162 }
 163
 164 int DumpRenderTreeSupportQt::workerThreadCount()
 165 {
 166 #if ENABLE(WORKERS)
 167     return WebCore::WorkerThread::workerThreadCount();
 168 #else
 169     return 0;
 170 #endif
 171 }
 172
 173 void DumpRenderTreeSupportQt::setDumpRenderTreeModeEnabled(bool b)
 174 {
 175     QWebPagePrivate::drtRun = b;
 176 }
 177
 178 void DumpRenderTreeSupportQt::setFrameFlatteningEnabled(QWebPage* page, bool enabled)
 179 {
 180     QWebPagePrivate::core(page)->settings()->setFrameFlatteningEnabled(enabled);
 181 }
 182
 183 void DumpRenderTreeSupportQt::webPageSetGroupName(QWebPage* page, const QString& groupName)
 184 {
 185     page->handle()->page->setGroupName(groupName);
 186 }
 187
 188 QString DumpRenderTreeSupportQt::webPageGroupName(QWebPage* page)
 189 {
 190     return page->handle()->page->groupName();
 191 }
 192
 193 void DumpRenderTreeSupportQt::webInspectorExecuteScript(QWebPage* page, long callId, const QString& script)
 194 {
 195 #if ENABLE(INSPECTOR)
 196     if (!page->handle()->page->inspectorController())
 197         return;
 198     page->handle()->page->inspectorController()->evaluateForTestInFrontend(callId, script);
 199 #endif
 200 }
 201
 202 void DumpRenderTreeSupportQt::webInspectorClose(QWebPage* page)
 203 {
 204 #if ENABLE(INSPECTOR)
 205     if (!page->handle()->page->inspectorController())
 206         return;
 207     page->handle()->page->inspectorController()->close();
 208 #endif
 209 }
 210
 211 void DumpRenderTreeSupportQt::webInspectorShow(QWebPage* page)
 212 {
 213 #if ENABLE(INSPECTOR)
 214     if (!page->handle()->page->inspectorController())
 215         return;
 216     page->handle()->page->inspectorController()->show();
 217 #endif
 218 }
 219
 220 void DumpRenderTreeSupportQt::setTimelineProfilingEnabled(QWebPage* page, bool enabled)
 221 {
 222 #if ENABLE(INSPECTOR)
 223     InspectorController* controller = page->handle()->page->inspectorController();
 224     if (!controller)
 225         return;
 226     if (enabled)
 227         controller->startTimelineProfiler();
 228     else
 229         controller->stopTimelineProfiler();
 230 #endif
 231 }
 232
 233 bool DumpRenderTreeSupportQt::hasDocumentElement(QWebFrame* frame)
 234 {
 235     return QWebFramePrivate::core(frame)->document()->documentElement();
 236 }
 237
 238 void DumpRenderTreeSupportQt::setJavaScriptProfilingEnabled(QWebFrame* frame, bool enabled)
 239 {
 240 #if ENABLE(JAVASCRIPT_DEBUGGER) && ENABLE(INSPECTOR)
 241     Frame* coreFrame = QWebFramePrivate::core(frame);
 242     InspectorController* controller = coreFrame->page()->inspectorController();
 243     if (!controller)
 244         return;
 245     if (enabled)
 246         controller->enableProfiler();
 247     else
 248         controller->disableProfiler();
 249 #endif
 250 }
 251
 252 // Pause a given CSS animation or transition on the target node at a specific time.
 253 // If the animation or transition is already paused, it will update its pause time.
 254 // This method is only intended to be used for testing the CSS animation and transition system.
 255 bool DumpRenderTreeSupportQt::pauseAnimation(QWebFrame *frame, const QString &animationName, double time, const QString &elementId)
 256 {
 257     Frame* coreFrame = QWebFramePrivate::core(frame);
 258     if (!coreFrame)
 259         return false;
 260
 261     AnimationController* controller = coreFrame->animation();
 262     if (!controller)
 263         return false;
 264
 265     Document* doc = coreFrame->document();
 266     Q_ASSERT(doc);
 267
 268     Node* coreNode = doc->getElementById(elementId);
 269     if (!coreNode || !coreNode->renderer())
 270         return false;
 271
 272     return controller->pauseAnimationAtTime(coreNode->renderer(), animationName, time);
 273 }
 274
 275 bool DumpRenderTreeSupportQt::pauseTransitionOfProperty(QWebFrame *frame, const QString &propertyName, double time, const QString &elementId)
 276 {
 277     Frame* coreFrame = QWebFramePrivate::core(frame);
 278     if (!coreFrame)
 279         return false;
 280
 281     AnimationController* controller = coreFrame->animation();
 282     if (!controller)
 283         return false;
 284
 285     Document* doc = coreFrame->document();
 286     Q_ASSERT(doc);
 287
 288     Node* coreNode = doc->getElementById(elementId);
 289     if (!coreNode || !coreNode->renderer())
 290         return false;
 291
 292     return controller->pauseTransitionAtTime(coreNode->renderer(), propertyName, time);
 293 }
 294
 295 // Pause a given SVG animation on the target node at a specific time.
 296 // This method is only intended to be used for testing the SVG animation system.
 297 bool DumpRenderTreeSupportQt::pauseSVGAnimation(QWebFrame *frame, const QString &animationId, double time, const QString &elementId)
 298 {
 299 #if !ENABLE(SVG)
 300     return false;
 301 #else
 302     Frame* coreFrame = QWebFramePrivate::core(frame);
 303     if (!coreFrame)
 304         return false;
 305
 306     Document* doc = coreFrame->document();
 307     Q_ASSERT(doc);
 308
 309     if (!doc->svgExtensions())
 310         return false;
 311
 312     Node* coreNode = doc->getElementById(animationId);
 313     if (!coreNode || !SVGSMILElement::isSMILElement(coreNode))
 314         return false;
 315
 316     return doc->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time);
 317 #endif
 318 }
 319
 320 // Returns the total number of currently running animations (includes both CSS transitions and CSS animations).
 321 int DumpRenderTreeSupportQt::numberOfActiveAnimations(QWebFrame *frame)
 322 {
 323     Frame* coreFrame = QWebFramePrivate::core(frame);
 324     if (!coreFrame)
 325         return false;
 326
 327     AnimationController* controller = coreFrame->animation();
 328     if (!controller)
 329         return false;
 330
 331     return controller->numberOfActiveAnimations();
 332 }
 333
 334 void DumpRenderTreeSupportQt::suspendAnimations(QWebFrame *frame)
 335 {
 336     Frame* coreFrame = QWebFramePrivate::core(frame);
 337     if (!coreFrame)
 338         return;
 339
 340     AnimationController* controller = coreFrame->animation();
 341     if (!controller)
 342         return;
 343
 344     controller->suspendAnimations();
 345 }
 346
 347 void DumpRenderTreeSupportQt::resumeAnimations(QWebFrame *frame)
 348 {
 349     Frame* coreFrame = QWebFramePrivate::core(frame);
 350     if (!coreFrame)
 351         return;
 352
 353     AnimationController* controller = coreFrame->animation();
 354     if (!controller)
 355         return;
 356
 357     controller->resumeAnimations();
 358 }
 359
 360 void DumpRenderTreeSupportQt::clearFrameName(QWebFrame* frame)
 361 {
 362     Frame* coreFrame = QWebFramePrivate::core(frame);
 363     coreFrame->tree()->clearName();
 364 }
 365
 366 int DumpRenderTreeSupportQt::javaScriptObjectsCount()
 367 {
 368 #if USE(JSC)
 369     return JSDOMWindowBase::commonJSGlobalData()->heap.globalObjectCount();
 370 #elif USE(V8)
 371     // FIXME: Find a way to do this using V8.
 372     return 1;
 373 #endif
 374 }
 375
 376 void DumpRenderTreeSupportQt::garbageCollectorCollect()
 377 {
 378 #if USE(JSC)
 379     gcController().garbageCollectNow();
 380 #elif USE(V8)
 381     v8::V8::LowMemoryNotification();
 382 #endif
 383 }
 384
 385 void DumpRenderTreeSupportQt::garbageCollectorCollectOnAlternateThread(bool waitUntilDone)
 386 {
 387 #if USE(JSC)
 388     gcController().garbageCollectOnAlternateThreadForDebugging(waitUntilDone);
 389 #elif USE(V8)
 390     // FIXME: Find a way to do this using V8.
 391     garbageCollectorCollect();
 392 #endif
 393 }
 394
 395 // Returns the value of counter in the element specified by \a id.
 396 QString DumpRenderTreeSupportQt::counterValueForElementById(QWebFrame* frame, const QString& id)
 397 {
 398     Frame* coreFrame = QWebFramePrivate::core(frame);
 399     if (Document* document = coreFrame->document()) {
 400         if (Element* element = document->getElementById(id))
 401             return WebCore::counterValueForElement(element);
 402     }
 403     return QString();
 404 }
 405
 406 int DumpRenderTreeSupportQt::pageNumberForElementById(QWebFrame* frame, const QString& id, float width, float height)
 407 {
 408     Frame* coreFrame = QWebFramePrivate::core(frame);
 409     if (!coreFrame)
 410         return -1;
 411
 412     Element* element = coreFrame->document()->getElementById(AtomicString(id));
 413     if (!element)
 414         return -1;
 415
 416     return PrintContext::pageNumberForElement(element, FloatSize(width, height));
 417 }
 418
 419 int DumpRenderTreeSupportQt::numberOfPages(QWebFrame* frame, float width, float height)
 420 {
 421     Frame* coreFrame = QWebFramePrivate::core(frame);
 422     if (!coreFrame)
 423         return -1;
 424
 425     return PrintContext::numberOfPages(coreFrame, FloatSize(width, height));
 426 }
 427
 428 // Suspend active DOM objects in this frame.
 429 void DumpRenderTreeSupportQt::suspendActiveDOMObjects(QWebFrame* frame)
 430 {
 431     Frame* coreFrame = QWebFramePrivate::core(frame);
 432     if (coreFrame->document())
 433         // FIXME: This function should be changed take a ReasonForSuspension parameter
 434         // https://bugs.webkit.org/show_bug.cgi?id=45732
 435         coreFrame->document()->suspendActiveDOMObjects(ActiveDOMObject::JavaScriptDebuggerPaused);
 436 }
 437
 438 // Resume active DOM objects in this frame.
 439 void DumpRenderTreeSupportQt::resumeActiveDOMObjects(QWebFrame* frame)
 440 {
 441     Frame* coreFrame = QWebFramePrivate::core(frame);
 442     if (coreFrame->document())
 443         coreFrame->document()->resumeActiveDOMObjects();
 444 }
 445
 446 void DumpRenderTreeSupportQt::whiteListAccessFromOrigin(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
 447 {
 448     SecurityOrigin::addOriginAccessWhitelistEntry(*SecurityOrigin::createFromString(sourceOrigin), destinationProtocol, destinationHost, allowDestinationSubdomains);
 449 }
 450
 451 void DumpRenderTreeSupportQt::removeWhiteListAccessFromOrigin(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
 452 {
 453     SecurityOrigin::removeOriginAccessWhitelistEntry(*SecurityOrigin::createFromString(sourceOrigin), destinationProtocol, destinationHost, allowDestinationSubdomains);
 454 }
 455
 456 void DumpRenderTreeSupportQt::resetOriginAccessWhiteLists()
 457 {
 458     SecurityOrigin::resetOriginAccessWhitelists();
 459 }
 460
 461 void DumpRenderTreeSupportQt::setDomainRelaxationForbiddenForURLScheme(bool forbidden, const QString& scheme)
 462 {
 463     SecurityOrigin::setDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 464 }
 465
 466 void DumpRenderTreeSupportQt::setCaretBrowsingEnabled(QWebPage* page, bool value)
 467 {
 468     page->handle()->page->settings()->setCaretBrowsingEnabled(value);
 469 }
 470
 471 void DumpRenderTreeSupportQt::setMediaType(QWebFrame* frame, const QString& type)
 472 {
 473     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 474     WebCore::FrameView* view = coreFrame->view();
 475     view->setMediaType(type);
 476     coreFrame->document()->styleSelectorChanged(RecalcStyleImmediately);
 477     view->layout();
 478 }
 479
 480 void DumpRenderTreeSupportQt::setSmartInsertDeleteEnabled(QWebPage* page, bool enabled)
 481 {
 482     page->d->smartInsertDeleteEnabled = enabled;
 483 }
 484
 485
 486 void DumpRenderTreeSupportQt::setSelectTrailingWhitespaceEnabled(QWebPage* page, bool enabled)
 487 {
 488     page->d->selectTrailingWhitespaceEnabled = enabled;
 489 }
 490
 491
 492 void DumpRenderTreeSupportQt::executeCoreCommandByName(QWebPage* page, const QString& name, const QString& value)
 493 {
 494     page->handle()->page->focusController()->focusedOrMainFrame()->editor()->command(name).execute(value);
 495 }
 496
 497 bool DumpRenderTreeSupportQt::isCommandEnabled(QWebPage* page, const QString& name)
 498 {
 499     return page->handle()->page->focusController()->focusedOrMainFrame()->editor()->command(name).isEnabled();
 500 }
 501
 502 bool DumpRenderTreeSupportQt::findString(QWebPage* page, const QString& string, const QStringList& optionArray)
 503 {
 504     // 1. Parse the options from the array
 505     WebCore::FindOptions options = 0;
 506     const int optionCount = optionArray.size();
 507     for (int i = 0; i < optionCount; ++i) {
 508         const QString& option = optionArray.at(i);
 509         if (option == QLatin1String("CaseInsensitive"))
 510             options |= WebCore::CaseInsensitive;
 511         else if (option == QLatin1String("AtWordStarts"))
 512             options |= WebCore::AtWordStarts;
 513         else if (option == QLatin1String("TreatMedialCapitalAsWordStart"))
 514             options |= WebCore::TreatMedialCapitalAsWordStart;
 515         else if (option == QLatin1String("Backwards"))
 516             options |= WebCore::Backwards;
 517         else if (option == QLatin1String("WrapAround"))
 518             options |= WebCore::WrapAround;
 519         else if (option == QLatin1String("StartInSelection"))
 520             options |= WebCore::StartInSelection;
 521     }
 522
 523     // 2. find the string
 524     WebCore::Frame* frame = page->handle()->page->focusController()->focusedOrMainFrame();
 525     return frame && frame->editor()->findString(string, options);
 526 }
 527
 528 QString DumpRenderTreeSupportQt::markerTextForListItem(const QWebElement& listItem)
 529 {
 530     return WebCore::markerTextForListItem(listItem.m_element);
 531 }
 532
 533 static QString convertToPropertyName(const QString& name)
 534 {
 535     QStringList parts = name.split(QLatin1Char('-'));
 536     QString camelCaseName;
 537     for (int j = 0; j < parts.count(); ++j) {
 538         QString part = parts.at(j);
 539         if (j)
 540             camelCaseName.append(part.replace(0, 1, part.left(1).toUpper()));
 541         else
 542             camelCaseName.append(part);
 543     }
 544     return camelCaseName;
 545 }
 546
 547 QVariantMap DumpRenderTreeSupportQt::computedStyleIncludingVisitedInfo(const QWebElement& element)
 548 {
 549     QVariantMap res;
 550
 551     WebCore::Element* webElement = element.m_element;
 552     if (!webElement)
 553         return res;
 554
 555     RefPtr<WebCore::CSSComputedStyleDeclaration> style = computedStyle(webElement, true);
 556     for (int i = 0; i < style->length(); i++) {
 557         QString name = style->item(i);
 558         QString value = (static_cast<WebCore::CSSStyleDeclaration*>(style.get()))->getPropertyValue(name);
 559         res[convertToPropertyName(name)] = QVariant(value);
 560     }
 561     return res;
 562 }
 563
 564 QVariantList DumpRenderTreeSupportQt::selectedRange(QWebPage* page)
 565 {
 566     WebCore::Frame* frame = page->handle()->page->focusController()->focusedOrMainFrame();
 567     QVariantList selectedRange;
 568     RefPtr<Range> range = frame->selection()->toNormalizedRange().get();
 569
 570     Element* selectionRoot = frame->selection()->rootEditableElement();
 571     Element* scope = selectionRoot ? selectionRoot : frame->document()->documentElement();
 572
 573     RefPtr<Range> testRange = Range::create(scope->document(), scope, 0, range->startContainer(), range->startOffset());
 574     ASSERT(testRange->startContainer() == scope);
 575     int startPosition = TextIterator::rangeLength(testRange.get());
 576
 577     ExceptionCode ec;
 578     testRange->setEnd(range->endContainer(), range->endOffset(), ec);
 579     ASSERT(testRange->startContainer() == scope);
 580     int endPosition = TextIterator::rangeLength(testRange.get());
 581
 582     selectedRange << startPosition << (endPosition - startPosition);
 583
 584     return selectedRange;
 585
 586 }
 587
 588 QVariantList DumpRenderTreeSupportQt::firstRectForCharacterRange(QWebPage* page, int location, int length)
 589 {
 590     WebCore::Frame* frame = page->handle()->page->focusController()->focusedOrMainFrame();
 591     QVariantList rect;
 592
 593     if ((location + length < location) && (location + length))
 594         length = 0;
 595
 596     Element* selectionRoot = frame->selection()->rootEditableElement();
 597     Element* scope = selectionRoot ? selectionRoot : frame->document()->documentElement();
 598     RefPtr<Range> range = TextIterator::rangeFromLocationAndLength(scope, location, length);
 599
 600     if (!range)
 601         return QVariantList();
 602
 603     QRect resultRect = frame->editor()->firstRectForRange(range.get());
 604     rect << resultRect.x() << resultRect.y() << resultRect.width() << resultRect.height();
 605     return rect;
 606 }
 607
 608 bool DumpRenderTreeSupportQt::elementDoesAutoCompleteForElementWithId(QWebFrame* frame, const QString& elementId)
 609 {
 610     Frame* coreFrame = QWebFramePrivate::core(frame);
 611     if (!coreFrame)
 612         return false;
 613
 614     Document* doc = coreFrame->document();
 615     Q_ASSERT(doc);
 616
 617     Node* coreNode = doc->getElementById(elementId);
 618     if (!coreNode || !coreNode->renderer())
 619         return false;
 620
 621     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(coreNode);
 622
 623     return inputElement->isTextField() && !inputElement->isPasswordField() && inputElement->autoComplete();
 624 }
 625
 626 void DumpRenderTreeSupportQt::setEditingBehavior(QWebPage* page, const QString& editingBehavior)
 627 {
 628     WebCore::EditingBehaviorType coreEditingBehavior;
 629
 630     if (editingBehavior == QLatin1String("win"))
 631         coreEditingBehavior = EditingWindowsBehavior;
 632     else if (editingBehavior == QLatin1String("mac"))
 633         coreEditingBehavior = EditingMacBehavior;
 634     else if (editingBehavior == QLatin1String("unix"))
 635         coreEditingBehavior = EditingUnixBehavior;
 636     else {
 637         ASSERT_NOT_REACHED();
 638         return;
 639     }
 640
 641     Page* corePage = QWebPagePrivate::core(page);
 642     if (!corePage)
 643         return;
 644
 645     corePage->settings()->setEditingBehaviorType(coreEditingBehavior);
 646 }
 647
 648 void DumpRenderTreeSupportQt::clearAllApplicationCaches()
 649 {
 650 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
 651     WebCore::cacheStorage().empty();
 652     WebCore::cacheStorage().vacuumDatabaseFile();
 653 #endif
 654 }
 655
 656 void DumpRenderTreeSupportQt::dumpFrameLoader(bool b)
 657 {
 658     FrameLoaderClientQt::dumpFrameLoaderCallbacks = b;
 659 }
 660
 661 void DumpRenderTreeSupportQt::dumpUserGestureInFrameLoader(bool b)
 662 {
 663     FrameLoaderClientQt::dumpUserGestureInFrameLoaderCallbacks = b;
 664 }
 665
 666 void DumpRenderTreeSupportQt::dumpResourceLoadCallbacks(bool b)
 667 {
 668     FrameLoaderClientQt::dumpResourceLoadCallbacks = b;
 669 }
 670
 671 void DumpRenderTreeSupportQt::dumpResourceLoadCallbacksPath(const QString& path)
 672 {
 673     FrameLoaderClientQt::dumpResourceLoadCallbacksPath = path;
 674 }
 675
 676 void DumpRenderTreeSupportQt::dumpResourceResponseMIMETypes(bool b)
 677 {
 678     FrameLoaderClientQt::dumpResourceResponseMIMETypes = b;
 679 }
 680
 681 void DumpRenderTreeSupportQt::setWillSendRequestReturnsNullOnRedirect(bool b)
 682 {
 683     FrameLoaderClientQt::sendRequestReturnsNullOnRedirect = b;
 684 }
 685
 686 void DumpRenderTreeSupportQt::setWillSendRequestReturnsNull(bool b)
 687 {
 688     FrameLoaderClientQt::sendRequestReturnsNull = b;
 689 }
 690
 691 void DumpRenderTreeSupportQt::setWillSendRequestClearHeaders(const QStringList& headers)
 692 {
 693     FrameLoaderClientQt::sendRequestClearHeaders = headers;
 694 }
 695
 696 void DumpRenderTreeSupportQt::setDeferMainResourceDataLoad(bool b)
 697 {
 698     FrameLoaderClientQt::deferMainResourceDataLoad = b;
 699 }
 700
 701 void DumpRenderTreeSupportQt::setCustomPolicyDelegate(bool enabled, bool permissive)
 702 {
 703     FrameLoaderClientQt::policyDelegateEnabled = enabled;
 704     FrameLoaderClientQt::policyDelegatePermissive = permissive;
 705 }
 706
 707 void DumpRenderTreeSupportQt::dumpHistoryCallbacks(bool b)
 708 {
 709     FrameLoaderClientQt::dumpHistoryCallbacks = b;
 710 }
 711
 712 void DumpRenderTreeSupportQt::dumpVisitedLinksCallbacks(bool b)
 713 {
 714     ChromeClientQt::dumpVisitedLinksCallbacks = b;
 715 }
 716
 717 void DumpRenderTreeSupportQt::dumpEditingCallbacks(bool b)
 718 {
 719     EditorClientQt::dumpEditingCallbacks = b;
 720 }
 721
 722 void DumpRenderTreeSupportQt::dumpSetAcceptsEditing(bool b)
 723 {
 724     EditorClientQt::acceptsEditing = b;
 725 }
 726
 727 void DumpRenderTreeSupportQt::dumpNotification(bool b)
 728 {
 729 #if ENABLE(NOTIFICATIONS)
 730     NotificationPresenterClientQt::dumpNotification = b;
 731 #endif
 732 }
 733
 734 QString DumpRenderTreeSupportQt::viewportAsText(QWebPage* page, int deviceDPI, const QSize& deviceSize, const QSize& availableSize)
 735 {
 736     WebCore::ViewportArguments args = page->d->viewportArguments();
 737
 738     WebCore::ViewportAttributes conf = WebCore::computeViewportAttributes(args,
 739         /* desktop-width */ 980,
 740         /* device-width  */ deviceSize.width(),
 741         /* device-height */ deviceSize.height(),
 742         /* device-dpi    */ deviceDPI,
 743         availableSize);
 744
 745     QString res;
 746     res = res.sprintf("viewport size %dx%d scale %f with limits [%f, %f] and userScalable %f\n",
 747             conf.layoutSize.width(),
 748             conf.layoutSize.height(),
 749             conf.initialScale,
 750             conf.minimumScale,
 751             conf.maximumScale,
 752             conf.userScalable);
 753
 754     return res;
 755 }
 756
 757 void DumpRenderTreeSupportQt::activeMockDeviceOrientationClient(bool b)
 758 {
 759 #if ENABLE(DEVICE_ORIENTATION)
 760     DeviceOrientationClientMockQt::mockIsActive = b;
 761 #endif
 762 }
 763
 764 void DumpRenderTreeSupportQt::removeMockDeviceOrientation()
 765 {
 766 #if ENABLE(DEVICE_ORIENTATION)
 767     DeviceOrientationClientMockQt* client = DeviceOrientationClientMockQt::client();
 768     delete client;
 769 #endif
 770 }
 771
 772 void DumpRenderTreeSupportQt::setMockDeviceOrientation(bool canProvideAlpha, double alpha, bool canProvideBeta, double beta, bool canProvideGamma, double gamma)
 773 {
 774 #if ENABLE(DEVICE_ORIENTATION)
 775     DeviceOrientationClientMockQt::client()->setOrientation(canProvideAlpha, alpha, canProvideBeta, beta, canProvideGamma, gamma);
 776 #endif
 777 }
 778
 779 void DumpRenderTreeSupportQt::resetGeolocationMock(QWebPage* page)
 780 {
 781 #if ENABLE(CLIENT_BASED_GEOLOCATION)
 782     Page* corePage = QWebPagePrivate::core(page);
 783     GeolocationClientMock* mockClient = toGeolocationClientMock(corePage->geolocationController()->client());
 784     mockClient->reset();
 785 #endif
 786 }
 787
 788 void DumpRenderTreeSupportQt::setMockGeolocationPermission(QWebPage* page, bool allowed)
 789 {
 790 #if ENABLE(CLIENT_BASED_GEOLOCATION)
 791     Page* corePage = QWebPagePrivate::core(page);
 792     GeolocationClientMock* mockClient = toGeolocationClientMock(corePage->geolocationController()->client());
 793     mockClient->setPermission(allowed);
 794 #endif
 795 }
 796
 797 void DumpRenderTreeSupportQt::setMockGeolocationPosition(QWebPage* page, double latitude, double longitude, double accuracy)
 798 {
 799 #if ENABLE(CLIENT_BASED_GEOLOCATION)
 800     Page* corePage = QWebPagePrivate::core(page);
 801     GeolocationClientMock* mockClient = toGeolocationClientMock(corePage->geolocationController()->client());
 802     mockClient->setPosition(GeolocationPosition::create(currentTime(), latitude, longitude, accuracy));
 803 #endif
 804 }
 805
 806 void DumpRenderTreeSupportQt::setMockGeolocationError(QWebPage* page, int errorCode, const QString& message)
 807 {
 808 #if ENABLE(CLIENT_BASED_GEOLOCATION)
 809     Page* corePage = QWebPagePrivate::core(page);
 810
 811     GeolocationError::ErrorCode code = GeolocationError::PositionUnavailable;
 812     switch (errorCode) {
 813     case PositionError::PERMISSION_DENIED:
 814         code = GeolocationError::PermissionDenied;
 815         break;
 816     case PositionError::POSITION_UNAVAILABLE:
 817         code = GeolocationError::PositionUnavailable;
 818         break;
 819     }
 820
 821     GeolocationClientMock* mockClient = static_cast<GeolocationClientMock*>(corePage->geolocationController()->client());
 822     mockClient->setError(GeolocationError::create(code, message));
 823 #endif
 824 }
 825
 826 int DumpRenderTreeSupportQt::numberOfPendingGeolocationPermissionRequests(QWebPage* page)
 827 {
 828 #if ENABLE(CLIENT_BASED_GEOLOCATION)
 829     Page* corePage = QWebPagePrivate::core(page);
 830     GeolocationClientMock* mockClient = toGeolocationClientMock(corePage->geolocationController()->client());
 831     return mockClient->numberOfPendingPermissionRequests();
 832 #else
 833     return -1;
 834 #endif
 835 }
 836
 837 bool DumpRenderTreeSupportQt::isTargetItem(const QWebHistoryItem& historyItem)
 838 {
 839     QWebHistoryItem it = historyItem;
 840     if (QWebHistoryItemPrivate::core(&it)->isTargetItem())
 841         return true;
 842     return false;
 843 }
 844
 845 QString DumpRenderTreeSupportQt::historyItemTarget(const QWebHistoryItem& historyItem)
 846 {
 847     QWebHistoryItem it = historyItem;
 848     return (QWebHistoryItemPrivate::core(&it)->target());
 849 }
 850
 851 QMap<QString, QWebHistoryItem> DumpRenderTreeSupportQt::getChildHistoryItems(const QWebHistoryItem& historyItem)
 852 {
 853     QWebHistoryItem it = historyItem;
 854     HistoryItem* item = QWebHistoryItemPrivate::core(&it);
 855     const WebCore::HistoryItemVector& children = item->children();
 856
 857     unsigned size = children.size();
 858     QMap<QString, QWebHistoryItem> kids;
 859     for (unsigned i = 0; i < size; ++i) {
 860         QWebHistoryItem kid(new QWebHistoryItemPrivate(children[i].get()));
 861         kids.insert(DumpRenderTreeSupportQt::historyItemTarget(kid), kid);
 862     }
 863     return kids;
 864 }
 865
 866 bool DumpRenderTreeSupportQt::shouldClose(QWebFrame* frame)
 867 {
 868     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 869     return coreFrame->loader()->shouldClose();
 870 }
 871
 872 void DumpRenderTreeSupportQt::clearScriptWorlds()
 873 {
 874     m_worldMap.clear();
 875 }
 876
 877 void DumpRenderTreeSupportQt::evaluateScriptInIsolatedWorld(QWebFrame* frame, int worldID, const QString& script)
 878 {
 879     QWebScriptWorld* scriptWorld;
 880     if (!worldID) {
 881         scriptWorld = new QWebScriptWorld();
 882     } else if (!m_worldMap.contains(worldID)) {
 883         scriptWorld = new QWebScriptWorld();
 884         m_worldMap.insert(worldID, scriptWorld);
 885     } else
 886         scriptWorld = m_worldMap.value(worldID);
 887
 888     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 889
 890     ScriptController* proxy = coreFrame->script();
 891
 892     if (!proxy)
 893         return;
 894 #if USE(JSC)
 895     proxy->executeScriptInWorld(scriptWorld->world(), script, true);
 896 #elif USE(V8)
 897     ScriptSourceCode source(script);
 898     Vector<ScriptSourceCode> sources;
 899     sources.append(source);
 900     proxy->evaluateInIsolatedWorld(0, sources, true);
 901 #endif
 902 }
 903
 904 bool DumpRenderTreeSupportQt::isPageBoxVisible(QWebFrame* frame, int pageIndex)
 905 {
 906     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 907     return coreFrame->document()->isPageBoxVisible(pageIndex);
 908 }
 909
 910 QString DumpRenderTreeSupportQt::pageSizeAndMarginsInPixels(QWebFrame* frame, int pageIndex, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft)
 911 {
 912     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 913     return PrintContext::pageSizeAndMarginsInPixels(coreFrame, pageIndex, width, height,
 914                                                     marginTop, marginRight, marginBottom, marginLeft);
 915 }
 916
 917 QString DumpRenderTreeSupportQt::pageProperty(QWebFrame* frame, const QString& propertyName, int pageNumber)
 918 {
 919     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 920     return PrintContext::pageProperty(coreFrame, propertyName.toUtf8().constData(), pageNumber);
 921 }
 922
 923 void DumpRenderTreeSupportQt::addUserStyleSheet(QWebPage* page, const QString& sourceCode)
 924 {
 925     page->handle()->page->group().addUserStyleSheetToWorld(mainThreadNormalWorld(), sourceCode, QUrl(), 0, 0, WebCore::InjectInAllFrames);
 926 }
 927
 928 void DumpRenderTreeSupportQt::simulateDesktopNotificationClick(const QString& title)
 929 {
 930 #if ENABLE(NOTIFICATIONS)
 931     NotificationPresenterClientQt::notificationPresenter()->notificationClicked(title);
 932 #endif
 933 }
 934
 935 QString DumpRenderTreeSupportQt::plainText(const QVariant& range)
 936 {
 937     QMap<QString, QVariant> map = range.toMap();
 938     QVariant startContainer  = map.value(QLatin1String("startContainer"));
 939     map = startContainer.toMap();
 940
 941     return map.value(QLatin1String("innerText")).toString();
 942 }
 943
 944 QVariantList DumpRenderTreeSupportQt::nodesFromRect(const QWebElement& document, int x, int y, unsigned top, unsigned right, unsigned bottom, unsigned left, bool ignoreClipping)
 945 {
 946     QVariantList res;
 947     WebCore::Element* webElement = document.m_element;
 948     if (!webElement)
 949         return res;
 950
 951     Document* doc = webElement->document();
 952     if (!doc)
 953         return res;
 954     RefPtr<NodeList> nodes = doc->nodesFromRect(x, y, top, right, bottom, left, ignoreClipping);
 955     for (int i = 0; i < nodes->length(); i++) {
 956         // QWebElement will be null if the Node is not an HTML Element
 957         if (nodes->item(i)->isHTMLElement())
 958             res << QVariant::fromValue(QWebElement(nodes->item(i)));
 959         else
 960             res << QVariant::fromValue(QDRTNode(nodes->item(i)));
 961     }
 962     return res;
 963 }
 964
 965 // API Candidate?
 966 QString DumpRenderTreeSupportQt::responseMimeType(QWebFrame* frame)
 967 {
 968     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 969     WebCore::DocumentLoader* docLoader = coreFrame->loader()->documentLoader();
 970     return docLoader->responseMIMEType();
 971 }
 972
 973 void DumpRenderTreeSupportQt::clearOpener(QWebFrame* frame)
 974 {
 975     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
 976     coreFrame->loader()->setOpener(0);
 977 }
 978
 979 void DumpRenderTreeSupportQt::addURLToRedirect(const QString& origin, const QString& destination)
 980 {
 981     FrameLoaderClientQt::URLsToRedirect[origin] = destination;
 982 }
 983
 984 static QStringList iterateContextMenu(QMenu* menu)
 985 {
 986     if (!menu)
 987         return QStringList();
 988
 989     QStringList items;
 990     QList<QAction *> actions = menu->actions();
 991     for (int i = 0; i < actions.count(); ++i) {
 992         if (actions.at(i)->isSeparator())
 993             items << QLatin1String("<separator>");
 994         else
 995             items << actions.at(i)->text();
 996         if (actions.at(i)->menu())
 997             items << iterateContextMenu(actions.at(i)->menu());
 998     }
 999     return items;
1000 }
1001
1002 QStringList DumpRenderTreeSupportQt::contextMenu(QWebPage* page)
1003 {
1004 #ifndef QT_NO_CONTEXTMENU
1005     return iterateContextMenu(page->d->currentContextMenu);
1006 #else
1007     return QStringList();
1008 #endif
1009 }
1010
1011 double DumpRenderTreeSupportQt::defaultMinimumTimerInterval()
1012 {
1013     return Settings::defaultMinDOMTimerInterval();
1014 }
1015
1016 void DumpRenderTreeSupportQt::setMinimumTimerInterval(QWebPage* page, double interval)
1017 {
1018     Page* corePage = QWebPagePrivate::core(page);
1019     if (!corePage)
1020         return;
1021
1022     corePage->settings()->setMinDOMTimerInterval(interval);
1023 }
1024
1025 QUrl DumpRenderTreeSupportQt::mediaContentUrlByElementId(QWebFrame* frame, const QString& elementId)
1026 {
1027     QUrl res;
1028
1029 #if ENABLE(VIDEO) && USE(QT_MULTIMEDIA)
1030     Frame* coreFrame = QWebFramePrivate::core(frame);
1031     if (!coreFrame)
1032         return res;
1033
1034     Document* doc = coreFrame->document();
1035     if (!doc)
1036         return res;
1037
1038     Node* coreNode = doc->getElementById(elementId);
1039     if (!coreNode)
1040         return res;
1041
1042     HTMLVideoElement* videoElement = static_cast<HTMLVideoElement*>(coreNode);
1043     PlatformMedia platformMedia = videoElement->platformMedia();
1044     if (platformMedia.type != PlatformMedia::QtMediaPlayerType)
1045         return res;
1046
1047     MediaPlayerPrivateQt* mediaPlayerQt = static_cast<MediaPlayerPrivateQt*>(platformMedia.media.qtMediaPlayer);
1048     if (mediaPlayerQt && mediaPlayerQt->mediaPlayer())
1049         res = mediaPlayerQt->mediaPlayer()->media().canonicalUrl();
1050 #endif
1051
1052     return res;
1053 }
1054
1055 // API Candidate?
1056 void DumpRenderTreeSupportQt::setAlternateHtml(QWebFrame* frame, const QString& html, const QUrl& baseUrl, const QUrl& failingUrl)
1057 {
1058     KURL kurl(baseUrl);
1059     WebCore::Frame* coreFrame = QWebFramePrivate::core(frame);
1060     WebCore::ResourceRequest request(kurl);
1061     const QByteArray utf8 = html.toUtf8();
1062     WTF::RefPtr<WebCore::SharedBuffer> data = WebCore::SharedBuffer::create(utf8.constData(), utf8.length());
1063     WebCore::SubstituteData substituteData(data, WTF::String("text/html"), WTF::String("utf-8"), failingUrl);
1064     coreFrame->loader()->load(request, substituteData, false);
1065 }
1066
1067 QVariant DumpRenderTreeSupportQt::shadowRoot(const QWebElement& element)
1068 {
1069     WebCore::Element* webElement = element.m_element;
1070     if (!webElement)
1071         return QVariant();
1072
1073     ContainerNode* webShadowRoot = webElement->shadowRoot();
1074     if (!webShadowRoot)
1075         return QVariant();
1076
1077     return QVariant::fromValue(QDRTNode(webShadowRoot));
1078 }
1079
1080 // Provide a backward compatibility with previously exported private symbols as of QtWebKit 4.6 release
1081
1082 void QWEBKIT_EXPORT qt_resumeActiveDOMObjects(QWebFrame* frame)
1083 {
1084     DumpRenderTreeSupportQt::resumeActiveDOMObjects(frame);
1085 }
1086
1087 void QWEBKIT_EXPORT qt_suspendActiveDOMObjects(QWebFrame* frame)
1088 {
1089     DumpRenderTreeSupportQt::suspendActiveDOMObjects(frame);
1090 }
1091
1092 void QWEBKIT_EXPORT qt_drt_clearFrameName(QWebFrame* frame)
1093 {
1094     DumpRenderTreeSupportQt::clearFrameName(frame);
1095 }
1096
1097 void QWEBKIT_EXPORT qt_drt_garbageCollector_collect()
1098 {
1099     DumpRenderTreeSupportQt::garbageCollectorCollect();
1100 }
1101
1102 void QWEBKIT_EXPORT qt_drt_garbageCollector_collectOnAlternateThread(bool waitUntilDone)
1103 {
1104     DumpRenderTreeSupportQt::garbageCollectorCollectOnAlternateThread(waitUntilDone);
1105 }
1106
1107 int QWEBKIT_EXPORT qt_drt_javaScriptObjectsCount()
1108 {
1109     return DumpRenderTreeSupportQt::javaScriptObjectsCount();
1110 }
1111
1112 int QWEBKIT_EXPORT qt_drt_numberOfActiveAnimations(QWebFrame* frame)
1113 {
1114     return DumpRenderTreeSupportQt::numberOfActiveAnimations(frame);
1115 }
1116
1117 void QWEBKIT_EXPORT qt_drt_overwritePluginDirectories()
1118 {
1119     DumpRenderTreeSupportQt::overwritePluginDirectories();
1120 }
1121
1122 bool QWEBKIT_EXPORT qt_drt_pauseAnimation(QWebFrame* frame, const QString& animationName, double time, const QString& elementId)
1123 {
1124     return DumpRenderTreeSupportQt::pauseAnimation(frame, animationName, time, elementId);
1125 }
1126
1127 bool QWEBKIT_EXPORT qt_drt_pauseTransitionOfProperty(QWebFrame* frame, const QString& propertyName, double time, const QString &elementId)
1128 {
1129     return DumpRenderTreeSupportQt::pauseTransitionOfProperty(frame, propertyName, time, elementId);
1130 }
1131
1132 void QWEBKIT_EXPORT qt_drt_resetOriginAccessWhiteLists()
1133 {
1134     DumpRenderTreeSupportQt::resetOriginAccessWhiteLists();
1135 }
1136
1137 void QWEBKIT_EXPORT qt_drt_run(bool b)
1138 {
1139     DumpRenderTreeSupportQt::setDumpRenderTreeModeEnabled(b);
1140 }
1141
1142 void QWEBKIT_EXPORT qt_drt_setJavaScriptProfilingEnabled(QWebFrame* frame, bool enabled)
1143 {
1144     DumpRenderTreeSupportQt::setJavaScriptProfilingEnabled(frame, enabled);
1145 }
1146
1147 void QWEBKIT_EXPORT qt_drt_whiteListAccessFromOrigin(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
1148 {
1149     DumpRenderTreeSupportQt::whiteListAccessFromOrigin(sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains);
1150 }
1151
1152 QString QWEBKIT_EXPORT qt_webpage_groupName(QWebPage* page)
1153 {
1154     return DumpRenderTreeSupportQt::webPageGroupName(page);
1155 }
1156
1157 void QWEBKIT_EXPORT qt_webpage_setGroupName(QWebPage* page, const QString& groupName)
1158 {
1159     DumpRenderTreeSupportQt::webPageSetGroupName(page, groupName);
1160 }
1161
1162 void QWEBKIT_EXPORT qt_dump_frame_loader(bool b)
1163 {
1164     DumpRenderTreeSupportQt::dumpFrameLoader(b);
1165 }
1166
1167 void QWEBKIT_EXPORT qt_dump_resource_load_callbacks(bool b)
1168 {
1169     DumpRenderTreeSupportQt::dumpResourceLoadCallbacks(b);
1170 }
1171
1172 void QWEBKIT_EXPORT qt_dump_editing_callbacks(bool b)
1173 {
1174     DumpRenderTreeSupportQt::dumpEditingCallbacks(b);
1175 }
1176
1177 void QWEBKIT_EXPORT qt_dump_set_accepts_editing(bool b)
1178 {
1179     DumpRenderTreeSupportQt::dumpSetAcceptsEditing(b);
1180 }
1181