Changeset 141596 in webkit


Ignore:
Timestamp:
Feb 1, 2013 8:02:07 AM (11 years ago)
Author:
jochen@chromium.org
Message:

[chromium] move ownership of TestRunner object to TestInterfaces
​https://bugs.webkit.org/show_bug.cgi?id=108464

Reviewed by Adam Barth.

Before, TestShell owned the class. This also removes the last include
from DumpRenderTree to TestRunner/src.

This also deletes TestDelegate and uses WebTestDelegate everywhere
instead.

  • DumpRenderTree/DumpRenderTree.gypi:
  • DumpRenderTree/chromium/TestRunner/public/WebTestInterfaces.h:

(WebTestInterfaces):

  • DumpRenderTree/chromium/TestRunner/public/WebTestRunner.h:

(WebKit):
(WebTestRunner):

  • DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.cpp:
  • DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h:

(WebTestRunner):
(WebTestRunner::AccessibilityController::setDelegate):
(AccessibilityController):

  • DumpRenderTree/chromium/TestRunner/src/EventSender.cpp:

(WebTestRunner):
(WebTestRunner::makeMenuItemStringsFor):

  • DumpRenderTree/chromium/TestRunner/src/EventSender.h:

(WebTestRunner):
(WebTestRunner::EventSender::setDelegate):
(EventSender):

  • DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp:

(WebTestRunner::GamepadController::setDelegate):

  • DumpRenderTree/chromium/TestRunner/src/GamepadController.h:

(WebTestRunner):
(GamepadController):

  • DumpRenderTree/chromium/TestRunner/src/TestDelegate.h: Removed.
  • DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp:

(WebTestRunner::TestInterfaces::TestInterfaces):
(WebTestRunner::TestInterfaces::~TestInterfaces):
(WebTestRunner::TestInterfaces::setWebView):
(WebTestRunner::TestInterfaces::setDelegate):
(WebTestRunner::TestInterfaces::bindTo):
(WebTestRunner::TestInterfaces::resetAll):
(WebTestRunner):
(WebTestRunner::TestInterfaces::setTestIsRunning):
(WebTestRunner::TestInterfaces::testRunner):

  • DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h:

(WebTestRunner):
(TestInterfaces):

  • DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp:

(WebTestRunner::TestRunner::TestRunner):
(WebTestRunner::TestRunner::reset):

  • DumpRenderTree/chromium/TestRunner/src/TestRunner.h:

(WebKit):
(TestRunner):

  • DumpRenderTree/chromium/TestRunner/src/WebTestInterfaces.cpp:

(WebTestRunner::WebTestInterfaces::Internal::testRunner):
(WebTestInterfaces::Internal):
(WebTestRunner::WebTestInterfaces::Internal::Internal):
(WebTestRunner::WebTestInterfaces::Internal::setDelegate):
(WebTestRunner::WebTestInterfaces::Internal::setTestIsRunning):

  • DumpRenderTree/chromium/TestRunner/src/WebTestRunner.cpp: Added.

(WebTestRunner):
(WebTestRunner::WebTestRunner::WebTestRunner):
(WebTestRunner::WebTestRunner::shouldDumpEditingCallbacks):
(WebTestRunner::WebTestRunner::shouldDumpAsText):
(WebTestRunner::WebTestRunner::setShouldDumpAsText):
(WebTestRunner::WebTestRunner::shouldGeneratePixelResults):
(WebTestRunner::WebTestRunner::setShouldGeneratePixelResults):
(WebTestRunner::WebTestRunner::shouldDumpChildFrameScrollPositions):
(WebTestRunner::WebTestRunner::shouldDumpChildFramesAsText):
(WebTestRunner::WebTestRunner::shouldDumpAsAudio):
(WebTestRunner::WebTestRunner::audioData):
(WebTestRunner::WebTestRunner::shouldDumpFrameLoadCallbacks):
(WebTestRunner::WebTestRunner::setShouldDumpFrameLoadCallbacks):
(WebTestRunner::WebTestRunner::shouldDumpUserGestureInFrameLoadCallbacks):
(WebTestRunner::WebTestRunner::stopProvisionalFrameLoads):
(WebTestRunner::WebTestRunner::shouldDumpTitleChanges):
(WebTestRunner::WebTestRunner::shouldDumpCreateView):
(WebTestRunner::WebTestRunner::canOpenWindows):
(WebTestRunner::WebTestRunner::shouldDumpResourceLoadCallbacks):
(WebTestRunner::WebTestRunner::shouldDumpResourceRequestCallbacks):
(WebTestRunner::WebTestRunner::shouldDumpResourceResponseMIMETypes):
(WebTestRunner::WebTestRunner::webPermissions):
(WebTestRunner::WebTestRunner::shouldDumpStatusCallbacks):
(WebTestRunner::WebTestRunner::shouldDumpProgressFinishedCallback):
(WebTestRunner::WebTestRunner::shouldDumpBackForwardList):
(WebTestRunner::WebTestRunner::deferMainResourceDataLoad):
(WebTestRunner::WebTestRunner::shouldDumpSelectionRect):
(WebTestRunner::WebTestRunner::testRepaint):
(WebTestRunner::WebTestRunner::sweepHorizontally):
(WebTestRunner::WebTestRunner::isPrinting):
(WebTestRunner::WebTestRunner::shouldStayOnPageAfterHandlingBeforeUnload):
(WebTestRunner::WebTestRunner::setTitleTextDirection):
(WebTestRunner::WebTestRunner::httpHeadersToClear):
(WebTestRunner::WebTestRunner::shouldBlockRedirects):
(WebTestRunner::WebTestRunner::willSendRequestShouldReturnNull):
(WebTestRunner::WebTestRunner::setTopLoadingFrame):
(WebTestRunner::WebTestRunner::topLoadingFrame):
(WebTestRunner::WebTestRunner::policyDelegateDone):
(WebTestRunner::WebTestRunner::policyDelegateEnabled):
(WebTestRunner::WebTestRunner::policyDelegateIsPermissive):
(WebTestRunner::WebTestRunner::policyDelegateShouldNotifyDone):
(WebTestRunner::WebTestRunner::shouldInterceptPostMessage):
(WebTestRunner::WebTestRunner::isSmartInsertDeleteEnabled):
(WebTestRunner::WebTestRunner::isSelectTrailingWhitespaceEnabled):

  • DumpRenderTree/chromium/TestShell.cpp:

(TestShell::initialize):
(TestShell::createMainWindow):
(TestShell::~TestShell):
(TestShell::runFileTest):
(TestShell::resetTestController):
(TestShell::dump):
(TestShell::bindJSObjectsToWindow):

  • DumpRenderTree/chromium/TestShell.h:

(TestShell::testRunner):
(TestShell):

Location:
trunk/Tools
Files:
1 added
1 deleted
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r141590 r141596  
     12013-02-01  Jochen Eisinger  <jochen@chromium.org>
     2
     3        [chromium] move ownership of TestRunner object to TestInterfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=108464
     5
     6        Reviewed by Adam Barth.
     7
     8        Before, TestShell owned the class. This also removes the last include
     9        from DumpRenderTree to TestRunner/src.
     10
     11        This also deletes TestDelegate and uses WebTestDelegate everywhere
     12        instead.
     13
     14        * DumpRenderTree/DumpRenderTree.gypi:
     15        * DumpRenderTree/chromium/TestRunner/public/WebTestInterfaces.h:
     16        (WebTestInterfaces):
     17        * DumpRenderTree/chromium/TestRunner/public/WebTestRunner.h:
     18        (WebKit):
     19        (WebTestRunner):
     20        * DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.cpp:
     21        * DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h:
     22        (WebTestRunner):
     23        (WebTestRunner::AccessibilityController::setDelegate):
     24        (AccessibilityController):
     25        * DumpRenderTree/chromium/TestRunner/src/EventSender.cpp:
     26        (WebTestRunner):
     27        (WebTestRunner::makeMenuItemStringsFor):
     28        * DumpRenderTree/chromium/TestRunner/src/EventSender.h:
     29        (WebTestRunner):
     30        (WebTestRunner::EventSender::setDelegate):
     31        (EventSender):
     32        * DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp:
     33        (WebTestRunner::GamepadController::setDelegate):
     34        * DumpRenderTree/chromium/TestRunner/src/GamepadController.h:
     35        (WebTestRunner):
     36        (GamepadController):
     37        * DumpRenderTree/chromium/TestRunner/src/TestDelegate.h: Removed.
     38        * DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp:
     39        (WebTestRunner::TestInterfaces::TestInterfaces):
     40        (WebTestRunner::TestInterfaces::~TestInterfaces):
     41        (WebTestRunner::TestInterfaces::setWebView):
     42        (WebTestRunner::TestInterfaces::setDelegate):
     43        (WebTestRunner::TestInterfaces::bindTo):
     44        (WebTestRunner::TestInterfaces::resetAll):
     45        (WebTestRunner):
     46        (WebTestRunner::TestInterfaces::setTestIsRunning):
     47        (WebTestRunner::TestInterfaces::testRunner):
     48        * DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h:
     49        (WebTestRunner):
     50        (TestInterfaces):
     51        * DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp:
     52        (WebTestRunner::TestRunner::TestRunner):
     53        (WebTestRunner::TestRunner::reset):
     54        * DumpRenderTree/chromium/TestRunner/src/TestRunner.h:
     55        (WebKit):
     56        (TestRunner):
     57        * DumpRenderTree/chromium/TestRunner/src/WebTestInterfaces.cpp:
     58        (WebTestRunner::WebTestInterfaces::Internal::testRunner):
     59        (WebTestInterfaces::Internal):
     60        (WebTestRunner::WebTestInterfaces::Internal::Internal):
     61        (WebTestRunner::WebTestInterfaces::Internal::setDelegate):
     62        (WebTestRunner::WebTestInterfaces::Internal::setTestIsRunning):
     63        * DumpRenderTree/chromium/TestRunner/src/WebTestRunner.cpp: Added.
     64        (WebTestRunner):
     65        (WebTestRunner::WebTestRunner::WebTestRunner):
     66        (WebTestRunner::WebTestRunner::shouldDumpEditingCallbacks):
     67        (WebTestRunner::WebTestRunner::shouldDumpAsText):
     68        (WebTestRunner::WebTestRunner::setShouldDumpAsText):
     69        (WebTestRunner::WebTestRunner::shouldGeneratePixelResults):
     70        (WebTestRunner::WebTestRunner::setShouldGeneratePixelResults):
     71        (WebTestRunner::WebTestRunner::shouldDumpChildFrameScrollPositions):
     72        (WebTestRunner::WebTestRunner::shouldDumpChildFramesAsText):
     73        (WebTestRunner::WebTestRunner::shouldDumpAsAudio):
     74        (WebTestRunner::WebTestRunner::audioData):
     75        (WebTestRunner::WebTestRunner::shouldDumpFrameLoadCallbacks):
     76        (WebTestRunner::WebTestRunner::setShouldDumpFrameLoadCallbacks):
     77        (WebTestRunner::WebTestRunner::shouldDumpUserGestureInFrameLoadCallbacks):
     78        (WebTestRunner::WebTestRunner::stopProvisionalFrameLoads):
     79        (WebTestRunner::WebTestRunner::shouldDumpTitleChanges):
     80        (WebTestRunner::WebTestRunner::shouldDumpCreateView):
     81        (WebTestRunner::WebTestRunner::canOpenWindows):
     82        (WebTestRunner::WebTestRunner::shouldDumpResourceLoadCallbacks):
     83        (WebTestRunner::WebTestRunner::shouldDumpResourceRequestCallbacks):
     84        (WebTestRunner::WebTestRunner::shouldDumpResourceResponseMIMETypes):
     85        (WebTestRunner::WebTestRunner::webPermissions):
     86        (WebTestRunner::WebTestRunner::shouldDumpStatusCallbacks):
     87        (WebTestRunner::WebTestRunner::shouldDumpProgressFinishedCallback):
     88        (WebTestRunner::WebTestRunner::shouldDumpBackForwardList):
     89        (WebTestRunner::WebTestRunner::deferMainResourceDataLoad):
     90        (WebTestRunner::WebTestRunner::shouldDumpSelectionRect):
     91        (WebTestRunner::WebTestRunner::testRepaint):
     92        (WebTestRunner::WebTestRunner::sweepHorizontally):
     93        (WebTestRunner::WebTestRunner::isPrinting):
     94        (WebTestRunner::WebTestRunner::shouldStayOnPageAfterHandlingBeforeUnload):
     95        (WebTestRunner::WebTestRunner::setTitleTextDirection):
     96        (WebTestRunner::WebTestRunner::httpHeadersToClear):
     97        (WebTestRunner::WebTestRunner::shouldBlockRedirects):
     98        (WebTestRunner::WebTestRunner::willSendRequestShouldReturnNull):
     99        (WebTestRunner::WebTestRunner::setTopLoadingFrame):
     100        (WebTestRunner::WebTestRunner::topLoadingFrame):
     101        (WebTestRunner::WebTestRunner::policyDelegateDone):
     102        (WebTestRunner::WebTestRunner::policyDelegateEnabled):
     103        (WebTestRunner::WebTestRunner::policyDelegateIsPermissive):
     104        (WebTestRunner::WebTestRunner::policyDelegateShouldNotifyDone):
     105        (WebTestRunner::WebTestRunner::shouldInterceptPostMessage):
     106        (WebTestRunner::WebTestRunner::isSmartInsertDeleteEnabled):
     107        (WebTestRunner::WebTestRunner::isSelectTrailingWhitespaceEnabled):
     108        * DumpRenderTree/chromium/TestShell.cpp:
     109        (TestShell::initialize):
     110        (TestShell::createMainWindow):
     111        (TestShell::~TestShell):
     112        (TestShell::runFileTest):
     113        (TestShell::resetTestController):
     114        (TestShell::dump):
     115        (TestShell::bindJSObjectsToWindow):
     116        * DumpRenderTree/chromium/TestShell.h:
     117        (TestShell::testRunner):
     118        (TestShell):
     119
    11202013-02-01  Alan Cutter  <alancutter@chromium.org>
    2121

  • trunk/Tools/DumpRenderTree/DumpRenderTree.gypi

    r141082 r141596  
    9797            'chromium/TestRunner/src/WebTestPlugin.cpp',
    9898            'chromium/TestRunner/src/WebTestProxy.cpp',
     99            'chromium/TestRunner/src/WebTestRunner.cpp',
    99100        ],
    100101        'test_plugin_files': [

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestInterfaces.h

    r139090 r141596  
    5959    WebEventSender* eventSender();
    6060    WebTestRunner* testRunner();
    61     // FIXME: Remove this once TestRunner is complete.
    62     void setTestRunner(WebTestRunner*);
    6361
    6462private:

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestRunner.h

    r141298 r141596  
    3939class WebArrayBufferView;
    4040class WebPermissionClient;
     41class WebFrame;
    4142}
    4243
    4344namespace WebTestRunner {
    4445
    45 // FIXME: Once the TestRunner class is complete, this class should take a
    46 // TestRunner* as ctor argument, and not have default implementations.
     46class TestRunner;
     47
    4748class WebTestRunner {
    4849public:
    49     virtual void setTestIsRunning(bool) { }
    50     virtual bool shouldDumpEditingCallbacks() const { return false; }
    51     virtual bool shouldDumpAsText() const { return false; }
    52     virtual void setShouldDumpAsText(bool) { }
    53     virtual bool shouldGeneratePixelResults() const { return false; }
    54     virtual void setShouldGeneratePixelResults(bool) { }
    55     virtual bool shouldDumpChildFrameScrollPositions() const { return false; }
    56     virtual bool shouldDumpChildFramesAsText() const { return false; }
    57     virtual bool shouldDumpAsAudio() const { return false; }
    58     virtual const WebKit::WebArrayBufferView* audioData() const { return 0; }
    59     virtual bool shouldDumpFrameLoadCallbacks() const { return false; }
    60     virtual void setShouldDumpFrameLoadCallbacks(bool) { }
    61     virtual bool shouldDumpUserGestureInFrameLoadCallbacks() const { return false; }
    62     virtual bool stopProvisionalFrameLoads() const { return false; }
    63     virtual bool shouldDumpTitleChanges() const { return false; }
    64     virtual bool shouldDumpCreateView() const { return false; }
    65     virtual bool canOpenWindows() const { return false; }
    66     virtual bool shouldDumpResourceLoadCallbacks() const { return false; }
    67     virtual bool shouldDumpResourceRequestCallbacks() const { return false; }
    68     virtual bool shouldDumpResourceResponseMIMETypes() const { return false; }
    69     virtual WebKit::WebPermissionClient* webPermissions() const { return 0; }
    70     virtual bool shouldDumpStatusCallbacks() const { return false; }
    71     virtual bool shouldDumpProgressFinishedCallback() const { return false; }
    72     virtual bool shouldDumpBackForwardList() const { return false; }
    73     virtual bool deferMainResourceDataLoad() const { return false; }
    74     virtual bool shouldDumpSelectionRect() const { return false; }
    75     virtual bool testRepaint() const { return false; }
    76     virtual bool sweepHorizontally() const { return false; }
    77     virtual bool isPrinting() const { return false; }
    78     virtual bool shouldStayOnPageAfterHandlingBeforeUnload() const { return false; }
    79     virtual void setTitleTextDirection(WebKit::WebTextDirection) { }
    80     virtual const std::set<std::string>* httpHeadersToClear() const { return 0; }
    81     virtual bool shouldBlockRedirects() const { return false; }
    82     virtual bool willSendRequestShouldReturnNull() const { return false; }
    83     virtual void setTopLoadingFrame(WebKit::WebFrame*, bool) { }
    84     virtual WebKit::WebFrame* topLoadingFrame() const { return 0; }
    85     virtual void policyDelegateDone() { }
    86     virtual bool policyDelegateEnabled() const { return false; }
    87     virtual bool policyDelegateIsPermissive() const { return false; }
    88     virtual bool policyDelegateShouldNotifyDone() const { return false; }
    89     virtual bool shouldInterceptPostMessage() const { return false; }
    90     virtual bool isSmartInsertDeleteEnabled() const { return true; }
    91     virtual bool isSelectTrailingWhitespaceEnabled() const { return false; }
     50#if WEBTESTRUNNER_IMPLEMENTATION
     51    explicit WebTestRunner(TestRunner*);
     52#endif
     53
     54    virtual bool shouldDumpEditingCallbacks() const;
     55    virtual bool shouldDumpAsText() const;
     56    virtual void setShouldDumpAsText(bool);
     57    virtual bool shouldGeneratePixelResults() const;
     58    virtual void setShouldGeneratePixelResults(bool);
     59    virtual bool shouldDumpChildFrameScrollPositions() const;
     60    virtual bool shouldDumpChildFramesAsText() const;
     61    virtual bool shouldDumpAsAudio() const;
     62    virtual const WebKit::WebArrayBufferView* audioData() const;
     63    virtual bool shouldDumpFrameLoadCallbacks() const;
     64    virtual void setShouldDumpFrameLoadCallbacks(bool);
     65    virtual bool shouldDumpUserGestureInFrameLoadCallbacks() const;
     66    virtual bool stopProvisionalFrameLoads() const;
     67    virtual bool shouldDumpTitleChanges() const;
     68    virtual bool shouldDumpCreateView() const;
     69    virtual bool canOpenWindows() const;
     70    virtual bool shouldDumpResourceLoadCallbacks() const;
     71    virtual bool shouldDumpResourceRequestCallbacks() const;
     72    virtual bool shouldDumpResourceResponseMIMETypes() const;
     73    virtual WebKit::WebPermissionClient* webPermissions() const;
     74    virtual bool shouldDumpStatusCallbacks() const;
     75    virtual bool shouldDumpProgressFinishedCallback() const;
     76    virtual bool shouldDumpBackForwardList() const;
     77    virtual bool deferMainResourceDataLoad() const;
     78    virtual bool shouldDumpSelectionRect() const;
     79    virtual bool testRepaint() const;
     80    virtual bool sweepHorizontally() const;
     81    virtual bool isPrinting() const;
     82    virtual bool shouldStayOnPageAfterHandlingBeforeUnload() const;
     83    virtual void setTitleTextDirection(WebKit::WebTextDirection);
     84    virtual const std::set<std::string>* httpHeadersToClear() const;
     85    virtual bool shouldBlockRedirects() const;
     86    virtual bool willSendRequestShouldReturnNull() const;
     87    virtual void setTopLoadingFrame(WebKit::WebFrame*, bool);
     88    virtual WebKit::WebFrame* topLoadingFrame() const;
     89    virtual void policyDelegateDone();
     90    virtual bool policyDelegateEnabled() const;
     91    virtual bool policyDelegateIsPermissive() const;
     92    virtual bool policyDelegateShouldNotifyDone() const;
     93    virtual bool shouldInterceptPostMessage() const;
     94    virtual bool isSmartInsertDeleteEnabled() const;
     95    virtual bool isSelectTrailingWhitespaceEnabled() const;
     96
     97private:
     98    TestRunner* m_private;
    9299};
    93100

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.cpp

    r140565 r141596  
    3232#include "AccessibilityControllerChromium.h"
    3333
    34 #include "TestDelegate.h"
    3534#include "WebAccessibilityObject.h"
    3635#include "WebElement.h"
    3736#include "WebFrame.h"
    3837#include "WebNode.h"
     38#include "WebTestDelegate.h"
    3939#include "WebView.h"
    4040#include <public/WebCString.h>

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/AccessibilityControllerChromium.h

    r134203 r141596  
    4343namespace WebTestRunner {
    4444
    45 class TestDelegate;
     45class WebTestDelegate;
    4646
    4747class AccessibilityController : public CppBoundClass {
    … …  
    6262    void notificationReceived(const WebKit::WebAccessibilityObject& target, const char* notificationName);
    6363
    64     void setDelegate(TestDelegate* delegate) { m_delegate = delegate; }
     64    void setDelegate(WebTestDelegate* delegate) { m_delegate = delegate; }
    6565    void setWebView(WebKit::WebView* webView) { m_webView = webView; }
    6666
    … …  
    8888    std::vector<CppVariant> m_notificationCallbacks;
    8989
    90     TestDelegate* m_delegate;
     90    WebTestDelegate* m_delegate;
    9191    WebKit::WebView* m_webView;
    9292};

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.cpp

    r141514 r141596  
    4646#include "KeyCodeMapping.h"
    4747#include "MockSpellCheck.h"
    48 #include "TestDelegate.h"
    4948#include "WebContextMenuData.h"
    5049#include "WebDragOperation.h"
    5150#include "WebEventSender.h"
     51#include "WebTestDelegate.h"
    5252#include "WebTouchPoint.h"
    5353#include "WebView.h"
    … …  
    128128uint32 timeOffsetMs = 0;
    129129
    130 double getCurrentEventTimeSec(TestDelegate* delegate)
     130double getCurrentEventTimeSec(WebTestDelegate* delegate)
    131131{
    132132    return (delegate->getCurrentTimeInMillisecond() + timeOffsetMs) / 1000.0;
    … …  
    814814// - Some test even checks actual string content. So providing it would be also helpful.
    815815//
    816 static Vector<WebString> makeMenuItemStringsFor(WebContextMenuData* contextMenu, TestDelegate* delegate)
     816static Vector<WebString> makeMenuItemStringsFor(WebContextMenuData* contextMenu, WebTestDelegate* delegate)
    817817{
    818818    // These constants are based on Safari's context menu because tests are made for it.

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/EventSender.h

    r141514 r141596  
    5151namespace WebTestRunner {
    5252
    53 class TestDelegate;
     53class WebTestDelegate;
    5454
    5555class EventSender : public CppBoundClass {
    … …  
    5757    EventSender();
    5858
    59     void setDelegate(TestDelegate* delegate) { m_delegate = delegate; }
     59    void setDelegate(WebTestDelegate* delegate) { m_delegate = delegate; }
    6060    void setWebView(WebKit::WebView* webView) { m_webView = webView; }
    6161
    … …  
    171171    WebTaskList m_taskList;
    172172
    173     TestDelegate* m_delegate;
     173    WebTestDelegate* m_delegate;
    174174    WebKit::WebView* m_webView;
    175175

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.cpp

    r134203 r141596  
    3131#include "config.h"
    3232#include "GamepadController.h"
    33 #include "TestDelegate.h"
     33#include "WebTestDelegate.h"
    3434
    3535using namespace WebKit;
    … …  
    5757}
    5858
    59 void GamepadController::setDelegate(TestDelegate* delegate)
     59void GamepadController::setDelegate(WebTestDelegate* delegate)
    6060{
    6161    m_delegate = delegate;

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/GamepadController.h

    r140565 r141596  
    4242namespace WebTestRunner {
    4343
    44 class TestDelegate;
     44class WebTestDelegate;
    4545
    4646class GamepadController : public CppBoundClass {
    … …  
    4949
    5050    void bindToJavascript(WebKit::WebFrame*, const WebKit::WebString& classname);
    51     void setDelegate(TestDelegate*);
     51    void setDelegate(WebTestDelegate*);
    5252    void reset();
    5353
    … …  
    6565    WebKit::WebGamepads m_gamepads;
    6666
    67     TestDelegate* m_delegate;
     67    WebTestDelegate* m_delegate;
    6868};
    6969

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.cpp

    r140565 r141596  
    3535#include "EventSender.h"
    3636#include "GamepadController.h"
     37#include "TestRunner.h"
    3738#include "TextInputController.h"
    3839#include <public/WebString.h>
    … …  
    5051    m_gamepadController = adoptPtr(new GamepadController());
    5152    m_textInputController = adoptPtr(new TextInputController());
     53    m_testRunner = adoptPtr(new TestRunner());
    5254}
    5355
    … …  
    5860    // m_gamepadController doesn't depend on WebView.
    5961    m_textInputController->setWebView(0);
     62    m_testRunner->setWebView(0);
    6063
    6164    m_accessibilityController->setDelegate(0);
    6265    m_eventSender->setDelegate(0);
    6366    m_gamepadController->setDelegate(0);
    64     // m_textInputController doesn't depend on TestDelegate.
     67    // m_textInputController doesn't depend on WebTestDelegate.
     68    m_testRunner->setDelegate(0);
    6569}
    6670
    … …  
    7175    // m_gamepadController doesn't depend on WebView.
    7276    m_textInputController->setWebView(webView);
     77    m_testRunner->setWebView(webView);
    7378}
    7479
    75 void TestInterfaces::setDelegate(TestDelegate* delegate)
     80void TestInterfaces::setDelegate(WebTestDelegate* delegate)
    7681{
    7782    m_accessibilityController->setDelegate(delegate);
    7883    m_eventSender->setDelegate(delegate);
    7984    m_gamepadController->setDelegate(delegate);
    80     // m_textInputController doesn't depend on TestDelegate.
     85    // m_textInputController doesn't depend on WebTestDelegate.
     86    m_testRunner->setDelegate(delegate);
    8187}
    8288
    … …  
    8793    m_gamepadController->bindToJavascript(frame, WebString::fromUTF8("gamepadController"));
    8894    m_textInputController->bindToJavascript(frame, WebString::fromUTF8("textInputController"));
     95    m_testRunner->bindToJavascript(frame, WebString::fromUTF8("testRunner"));
     96    m_testRunner->bindToJavascript(frame, WebString::fromUTF8("layoutTestController"));
    8997}
    9098
    … …  
    95103    m_gamepadController->reset();
    96104    // m_textInputController doesn't have any state to reset.
     105    m_testRunner->reset();
     106}
     107
     108void TestInterfaces::setTestIsRunning(bool running)
     109{
     110    m_testRunner->setTestIsRunning(running);
    97111}
    98112
    … …  
    107121}
    108122
     123TestRunner* TestInterfaces::testRunner()
     124{
     125    return m_testRunner.get();
    109126}
     127
     128}

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/TestInterfaces.h

    r134203 r141596  
    4444class EventSender;
    4545class GamepadController;
    46 class TestDelegate;
     46class TestRunner;
    4747class TextInputController;
     48class WebTestDelegate;
    4849
    4950class TestInterfaces {
    … …  
    5354
    5455    void setWebView(WebKit::WebView*);
    55     void setDelegate(TestDelegate*);
     56    void setDelegate(WebTestDelegate*);
    5657    void bindTo(WebKit::WebFrame*);
    5758    void resetAll();
     59    void setTestIsRunning(bool);
    5860
    5961    AccessibilityController* accessibilityController();
    6062    EventSender* eventSender();
     63    TestRunner* testRunner();
    6164
    6265private:
    … …  
    6568    OwnPtr<GamepadController> m_gamepadController;
    6669    OwnPtr<TextInputController> m_textInputController;
     70    OwnPtr<TestRunner> m_testRunner;
    6771};
    6872

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.cpp

    r141298 r141596  
    154154TestRunner::TestRunner()
    155155    : m_testIsRunning(false)
    156     , m_closeRemainingWindows(true)
    157156    , m_workQueue(this)
    158157    , m_delegate(0)
    159158    , m_webView(0)
    160     , m_topLoadingFrame(0)
    161159    , m_intentClient(adoptPtr(new EmptyWebDeliveredIntentClient))
    162160    , m_webPermissions(adoptPtr(new WebPermissions))
    … …  
    387385#endif
    388386
    389     // Reset the default quota for each origin to 5MB
    390     m_delegate->setDatabaseQuota(5 * 1024 * 1024);
    391     m_delegate->setDeviceScaleFactor(1);
    392     m_delegate->setAcceptAllCookies(false);
    393     m_delegate->setLocale("");
     387    if (m_delegate) {
     388        // Reset the default quota for each origin to 5MB
     389        m_delegate->setDatabaseQuota(5 * 1024 * 1024);
     390        m_delegate->setDeviceScaleFactor(1);
     391        m_delegate->setAcceptAllCookies(false);
     392        m_delegate->setLocale("");
     393    }
    394394
    395395    m_dumpEditingCallbacks = false;
    … …  
    441441    m_workQueue.reset();
    442442
    443     if (m_closeRemainingWindows)
     443    if (m_closeRemainingWindows && m_delegate)
    444444        m_delegate->closeRemainingWindows();
    445445    else

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/TestRunner.h

    r141298 r141596  
    3838#include "WebDeliveredIntentClient.h"
    3939#include "WebTask.h"
    40 #include "WebTestRunner.h"
     40#include "WebTextDirection.h"
    4141#include <public/WebURL.h>
     42#include <set>
     43#include <string>
    4244#include <wtf/Deque.h>
    4345
    4446namespace WebKit {
     47class WebArrayBufferView;
     48class WebPermissionClient;
    4549class WebView;
    4650}
    … …  
    5155class WebTestDelegate;
    5256
    53 class TestRunner : public CppBoundClass, public WebTestRunner {
     57class TestRunner : public CppBoundClass {
    5458public:
    5559    TestRunner();
    5660    virtual ~TestRunner();
    5761
    58     // FIXME: change this method to take a TestDelegate* instead.
    5962    void setDelegate(WebTestDelegate*);
    6063    void setWebView(WebKit::WebView* webView) { m_webView = webView; }
    … …  
    6467    WebTaskList* taskList() { return &m_taskList; }
    6568
    66     // WebTestRunner implementation.
    67     virtual void setTestIsRunning(bool) OVERRIDE;
    68     virtual bool shouldDumpEditingCallbacks() const OVERRIDE;
    69     virtual bool shouldDumpAsText() const OVERRIDE;
    70     virtual void setShouldDumpAsText(bool) OVERRIDE;
    71     virtual bool shouldGeneratePixelResults() const OVERRIDE;
    72     virtual void setShouldGeneratePixelResults(bool) OVERRIDE;
    73     virtual bool shouldDumpChildFrameScrollPositions() const OVERRIDE;
    74     virtual bool shouldDumpChildFramesAsText() const OVERRIDE;
    75     virtual bool shouldDumpAsAudio() const OVERRIDE;
    76     virtual const WebKit::WebArrayBufferView* audioData() const OVERRIDE;
    77     virtual bool shouldDumpFrameLoadCallbacks() const OVERRIDE;
    78     virtual void setShouldDumpFrameLoadCallbacks(bool) OVERRIDE;
    79     virtual bool shouldDumpUserGestureInFrameLoadCallbacks() const OVERRIDE;
    80     virtual bool stopProvisionalFrameLoads() const OVERRIDE;
    81     virtual bool shouldDumpTitleChanges() const OVERRIDE;
    82     virtual bool shouldDumpCreateView() const OVERRIDE;
    83     virtual bool canOpenWindows() const OVERRIDE;
    84     virtual bool shouldDumpResourceLoadCallbacks() const OVERRIDE;
    85     virtual bool shouldDumpResourceRequestCallbacks() const OVERRIDE;
    86     virtual bool shouldDumpResourceResponseMIMETypes() const OVERRIDE;
    87     virtual WebKit::WebPermissionClient* webPermissions() const OVERRIDE;
    88     virtual bool shouldDumpStatusCallbacks() const OVERRIDE;
    89     virtual bool shouldDumpProgressFinishedCallback() const OVERRIDE;
    90     virtual bool shouldDumpBackForwardList() const OVERRIDE;
    91     virtual bool deferMainResourceDataLoad() const OVERRIDE;
    92     virtual bool shouldDumpSelectionRect() const OVERRIDE;
    93     virtual bool testRepaint() const OVERRIDE;
    94     virtual bool sweepHorizontally() const OVERRIDE;
    95     virtual bool isPrinting() const OVERRIDE;
    96     virtual bool shouldStayOnPageAfterHandlingBeforeUnload() const OVERRIDE;
    97     virtual void setTitleTextDirection(WebKit::WebTextDirection) OVERRIDE;
    98     virtual const std::set<std::string>* httpHeadersToClear() const OVERRIDE;
    99     virtual bool shouldBlockRedirects() const OVERRIDE;
    100     virtual bool willSendRequestShouldReturnNull() const OVERRIDE;
    101     virtual void setTopLoadingFrame(WebKit::WebFrame*, bool) OVERRIDE;
    102     virtual WebKit::WebFrame* topLoadingFrame() const OVERRIDE;
    103     virtual void policyDelegateDone() OVERRIDE;
    104     virtual bool policyDelegateEnabled() const OVERRIDE;
    105     virtual bool policyDelegateIsPermissive() const OVERRIDE;
    106     virtual bool policyDelegateShouldNotifyDone() const OVERRIDE;
    107     virtual bool shouldInterceptPostMessage() const OVERRIDE;
    108     virtual bool isSmartInsertDeleteEnabled() const OVERRIDE;
    109     virtual bool isSelectTrailingWhitespaceEnabled() const OVERRIDE;
     69    void setTestIsRunning(bool);
     70    bool shouldDumpEditingCallbacks() const;
     71    bool shouldDumpAsText() const;
     72    void setShouldDumpAsText(bool);
     73    bool shouldGeneratePixelResults() const;
     74    void setShouldGeneratePixelResults(bool);
     75    bool shouldDumpChildFrameScrollPositions() const;
     76    bool shouldDumpChildFramesAsText() const;
     77    bool shouldDumpAsAudio() const;
     78    const WebKit::WebArrayBufferView* audioData() const;
     79    bool shouldDumpFrameLoadCallbacks() const;
     80    void setShouldDumpFrameLoadCallbacks(bool);
     81    bool shouldDumpUserGestureInFrameLoadCallbacks() const;
     82    bool stopProvisionalFrameLoads() const;
     83    bool shouldDumpTitleChanges() const;
     84    bool shouldDumpCreateView() const;
     85    bool canOpenWindows() const;
     86    bool shouldDumpResourceLoadCallbacks() const;
     87    bool shouldDumpResourceRequestCallbacks() const;
     88    bool shouldDumpResourceResponseMIMETypes() const;
     89    WebKit::WebPermissionClient* webPermissions() const;
     90    bool shouldDumpStatusCallbacks() const;
     91    bool shouldDumpProgressFinishedCallback() const;
     92    bool shouldDumpBackForwardList() const;
     93    bool deferMainResourceDataLoad() const;
     94    bool shouldDumpSelectionRect() const;
     95    bool testRepaint() const;
     96    bool sweepHorizontally() const;
     97    bool isPrinting() const;
     98    bool shouldStayOnPageAfterHandlingBeforeUnload() const;
     99    void setTitleTextDirection(WebKit::WebTextDirection);
     100    const std::set<std::string>* httpHeadersToClear() const;
     101    bool shouldBlockRedirects() const;
     102    bool willSendRequestShouldReturnNull() const;
     103    void setTopLoadingFrame(WebKit::WebFrame*, bool);
     104    WebKit::WebFrame* topLoadingFrame() const;
     105    void policyDelegateDone();
     106    bool policyDelegateEnabled() const;
     107    bool policyDelegateIsPermissive() const;
     108    bool policyDelegateShouldNotifyDone() const;
     109    bool shouldInterceptPostMessage() const;
     110    bool isSmartInsertDeleteEnabled() const;
     111    bool isSelectTrailingWhitespaceEnabled() const;
    110112
    111113    // A single item in the work queue.

  • trunk/Tools/DumpRenderTree/chromium/TestRunner/src/WebTestInterfaces.cpp

    r140396 r141596  
    3232#include "WebTestInterfaces.h"
    3333
    34 #include "TestDelegate.h"
    3534#include "TestInterfaces.h"
    3635#include "WebAccessibilityController.h"
    … …  
    4847namespace WebTestRunner {
    4948
    50 class WebTestInterfaces::Internal : public TestDelegate {
     49class WebTestInterfaces::Internal {
    5150public:
    5251    Internal();
    … …  
    6059    WebAccessibilityController* accessibilityController() { return &m_accessibilityController; }
    6160    WebEventSender* eventSender() { return &m_eventSender; }
    62     WebTestRunner* testRunner() { return m_testRunner; }
    63     void setTestRunner(WebTestRunner* testRunner) { m_testRunner = testRunner; }
    64 
    65     // TestDelegate implementation.
    66     virtual void clearContextMenuData();
    67     virtual void clearEditCommand();
    68     virtual void setEditCommand(const std::string& name, const std::string& value);
    69     virtual WebContextMenuData* lastContextMenuData() const;
    70     virtual void setGamepadData(const WebGamepads&);
    71     virtual void printMessage(const std::string& message);
    72     virtual void postTask(WebTask*);
    73     virtual void postDelayedTask(WebTask*, long long ms);
    74     virtual WebString registerIsolatedFileSystem(const WebVector<WebString>& absoluteFilenames);
    75     virtual long long getCurrentTimeInMillisecond();
    76     virtual WebKit::WebString getAbsoluteWebStringFromUTF8Path(const std::string& path);
     61    WebTestRunner* testRunner() { return &m_testRunner; }
    7762
    7863private:
    … …  
    8267    WebAccessibilityController m_accessibilityController;
    8368    WebEventSender m_eventSender;
    84     WebTestRunner* m_testRunner;
    85     WebTestDelegate* m_delegate;
     69    WebTestRunner m_testRunner;
    8670};
    8771
    … …  
    9175    , m_accessibilityController(m_interfaces.accessibilityController())
    9276    , m_eventSender(m_interfaces.eventSender())
    93     , m_testRunner(0)
    94     , m_delegate(0)
     77    , m_testRunner(m_interfaces.testRunner())
    9578{
    9679}
    … …  
    10285void WebTestInterfaces::Internal::setDelegate(WebTestDelegate* delegate)
    10386{
    104     if (delegate) {
    105         m_delegate = delegate;
    106         m_interfaces.setDelegate(this);
    107     } else {
    108         m_delegate = 0;
    109         m_interfaces.setDelegate(0);
    110     }
     87    m_interfaces.setDelegate(delegate);
    11188}
    11289
    … …  
    11996void WebTestInterfaces::Internal::setTestIsRunning(bool running)
    12097{
    121     if (m_testRunner)
    122         m_testRunner->setTestIsRunning(running);
    123 }
    124 
    125 void WebTestInterfaces::Internal::clearContextMenuData()
    126 {
    127     m_delegate->clearContextMenuData();
    128 }
    129 
    130 void WebTestInterfaces::Internal::clearEditCommand()
    131 {
    132     m_delegate->clearEditCommand();
    133 }
    134 
    135 void WebTestInterfaces::Internal::setEditCommand(const std::string& name, const std::string& value)
    136 {
    137     m_delegate->setEditCommand(name, value);
    138 }
    139 
    140 WebContextMenuData* WebTestInterfaces::Internal::lastContextMenuData() const
    141 {
    142     return m_delegate->lastContextMenuData();
    143 }
    144 
    145 void WebTestInterfaces::Internal::setGamepadData(const WebGamepads& pads)
    146 {
    147     m_delegate->setGamepadData(pads);
    148 }
    149 
    150 void WebTestInterfaces::Internal::printMessage(const std::string& message)
    151 {
    152     m_delegate->printMessage(message);
    153 }
    154 
    155 void WebTestInterfaces::Internal::postTask(WebTask* task)
    156 {
    157     m_delegate->postTask(task);
    158 }
    159 
    160 void WebTestInterfaces::Internal::postDelayedTask(WebTask* task, long long ms)
    161 {
    162     m_delegate->postDelayedTask(task, ms);
    163 }
    164 
    165 WebString WebTestInterfaces::Internal::registerIsolatedFileSystem(const WebVector<WebString>& absoluteFilenames)
    166 {
    167     return m_delegate->registerIsolatedFileSystem(absoluteFilenames);
    168 }
    169 
    170 long long WebTestInterfaces::Internal::getCurrentTimeInMillisecond()
    171 {
    172     return m_delegate->getCurrentTimeInMillisecond();
    173 }
    174 
    175 WebKit::WebString WebTestInterfaces::Internal::getAbsoluteWebStringFromUTF8Path(const std::string& path)
    176 {
    177     return m_delegate->getAbsoluteWebStringFromUTF8Path(path);
     98    m_interfaces.setTestIsRunning(running);
    17899}
    179100
    … …  
    233154}
    234155
    235 void WebTestInterfaces::setTestRunner(WebTestRunner* testRunner)
    236 {
    237     m_internal->setTestRunner(testRunner);
    238156}
    239 
    240 }

  • trunk/Tools/DumpRenderTree/chromium/TestShell.cpp

    r141082 r141596  
    4848#include "WebSettings.h"
    4949#include "WebTestProxy.h"
     50#include "WebTestRunner.h"
    5051#include "WebView.h"
    5152#include "WebViewHost.h"
    … …  
    162163    m_testInterfaces = adoptPtr(new WebTestInterfaces());
    163164    m_devToolsTestInterfaces = adoptPtr(new WebTestInterfaces());
    164     m_testRunner = adoptPtr(new TestRunner());
    165     m_testInterfaces->setTestRunner(m_testRunner.get());
    166     m_devToolsTestInterfaces->setTestRunner(m_testRunner.get());
    167165#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
    168166    m_notificationPresenter = adoptPtr(new NotificationPresenter(this));
    … …  
    188186    m_testInterfaces->setDelegate(m_webViewHost.get());
    189187    m_testInterfaces->setWebView(m_webView);
    190     m_testRunner->setDelegate(m_webViewHost.get());
    191     m_testRunner->setWebView(m_webView);
    192188    m_drtDevToolsAgent->setWebView(m_webView);
    193189}
    … …  
    199195    m_devToolsTestInterfaces->setDelegate(0);
    200196    m_devToolsTestInterfaces->setWebView(0);
    201     m_testRunner->setDelegate(0);
    202     m_testRunner->setWebView(0);
    203197    m_drtDevToolsAgent->setWebView(0);
    204198    if (m_webViewHost)
    … …  
    236230        m_drtDevToolsAgent->reset();
    237231        m_drtDevToolsClient.clear();
     232        m_devToolsTestInterfaces->setDelegate(0);
     233        m_devToolsTestInterfaces->setWebView(0);
    238234        closeWindow(m_devTools);
    239235        m_devTools = 0;
    … …  
    267263    string testUrl = m_params.testUrl.spec();
    268264
    269     m_testRunner->setShouldGeneratePixelResults(shouldDumpPixels);
     265    m_testInterfaces->testRunner()->setShouldGeneratePixelResults(shouldDumpPixels);
    270266
    271267    if (testUrl.find("loading/") != string::npos
    272268        || testUrl.find("loading\\") != string::npos)
    273         m_testRunner->setShouldDumpFrameLoadCallbacks(true);
     269        m_testInterfaces->testRunner()->setShouldDumpFrameLoadCallbacks(true);
    274270
    275271    if (testUrl.find("compositing/") != string::npos || testUrl.find("compositing\\") != string::npos) {
    … …  
    284280    if (testUrl.find("/dumpAsText/") != string::npos
    285281        || testUrl.find("\\dumpAsText\\") != string::npos) {
    286         m_testRunner->setShouldDumpAsText(true);
    287         m_testRunner->setShouldGeneratePixelResults(false);
     282        m_testInterfaces->testRunner()->setShouldDumpAsText(true);
     283        m_testInterfaces->testRunner()->setShouldGeneratePixelResults(false);
    288284    }
    289285
    … …  
    326322    m_testInterfaces->resetAll();
    327323    m_devToolsTestInterfaces->resetAll();
    328     m_testRunner->reset();
    329324    m_webViewHost->reset();
    330325#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
    … …  
    391386}
    392387
    393 void TestShell::testFinished()
    394 {
     388void TestShell::testFinished(WebViewHost* host)
     389{
     390    if (host == m_devTools)
     391        return;
     392
    395393    if (!m_testIsPending)
    396394        return;
    … …  
    405403{
    406404    m_printer.handleTimedOut();
    407     testFinished();
     405    testFinished(webViewHost());
    408406}
    409407
    … …  
    580578    if (!frame)
    581579        return;
    582     bool shouldDumpAsText = m_testRunner->shouldDumpAsText();
    583     bool shouldDumpAsAudio = m_testRunner->shouldDumpAsAudio();
    584     bool shouldGeneratePixelResults = m_testRunner->shouldGeneratePixelResults();
    585     bool shouldDumpAsPrinted = m_testRunner->isPrinting();
     580    bool shouldDumpAsText = m_testInterfaces->testRunner()->shouldDumpAsText();
     581    bool shouldDumpAsAudio = m_testInterfaces->testRunner()->shouldDumpAsAudio();
     582    bool shouldGeneratePixelResults = m_testInterfaces->testRunner()->shouldGeneratePixelResults();
     583    bool shouldDumpAsPrinted = m_testInterfaces->testRunner()->isPrinting();
    586584    bool dumpedAnything = false;
    587585
    588586    if (shouldDumpAsAudio) {
    589         const WebKit::WebArrayBufferView* webArrayBufferView = m_testRunner->audioData();
     587        const WebKit::WebArrayBufferView* webArrayBufferView = m_testInterfaces->testRunner()->audioData();
    590588        m_printer.handleAudio(webArrayBufferView->baseAddress(), webArrayBufferView->byteLength());
    591589        m_printer.handleAudioFooter();
    … …  
    611609        }
    612610        if (shouldDumpAsText) {
    613             bool recursive = m_testRunner->shouldDumpChildFramesAsText();
     611            bool recursive = m_testInterfaces->testRunner()->shouldDumpChildFramesAsText();
    614612            string dataUtf8 = shouldDumpAsPrinted ? dumpFramesAsPrintedText(frame, recursive) : dumpFramesAsText(frame, recursive);
    615613            if (fwrite(dataUtf8.c_str(), 1, dataUtf8.size(), stdout) != dataUtf8.size())
    … …  
    622620                renderTextBehavior |= WebFrame::RenderAsTextDebug;
    623621            printf("%s", frame->renderTreeAsText(renderTextBehavior).utf8().data());
    624             bool recursive = m_testRunner->shouldDumpChildFrameScrollPositions();
     622            bool recursive = m_testInterfaces->testRunner()->shouldDumpChildFrameScrollPositions();
    625623            dumpFrameScrollPosition(frame, recursive);
    626624        }
    627         if (m_testRunner->shouldDumpBackForwardList())
     625        if (m_testInterfaces->testRunner()->shouldDumpBackForwardList())
    628626            printf("%s", dumpAllBackForwardLists().c_str());
    629627    }
    … …  
    637635        dumpedAnything = true;
    638636        m_webView->layout();
    639         if (m_testRunner->testRepaint()) {
     637        if (m_testInterfaces->testRunner()->testRepaint()) {
    640638            WebSize viewSize = m_webView->size();
    641639            int width = viewSize.width;
    642640            int height = viewSize.height;
    643             if (m_testRunner->sweepHorizontally()) {
     641            if (m_testInterfaces->testRunner()->sweepHorizontally()) {
    644642                for (WebRect column(0, 0, 1, height); column.x < width; column.x++)
    645643                    m_webViewHost->paintRect(column);
    … …  
    648646                    m_webViewHost->paintRect(line);
    649647            }
    650         } else if (m_testRunner->isPrinting())
     648        } else if (m_testInterfaces->testRunner()->isPrinting())
    651649            m_webViewHost->paintPagesWithBoundaries();
    652650        else
    … …  
    656654        // rect is the rect enclosing the (possibly transformed) selection.
    657655        // The rect should be drawn after everything is laid out and painted.
    658         if (m_testRunner->shouldDumpSelectionRect()) {
     656        if (m_testInterfaces->testRunner()->shouldDumpSelectionRect()) {
    659657            // If there is a selection rect - draw a red 1px border enclosing rect
    660658            WebRect wr = frame->selectionBoundsRect();
    … …  
    753751    else
    754752        m_testInterfaces->bindTo(frame);
    755     m_testRunner->bindToJavascript(frame, WebString::fromUTF8("testRunner"));
    756     m_testRunner->bindToJavascript(frame, WebString::fromUTF8("layoutTestController"));
    757753}
    758754

  • trunk/Tools/DumpRenderTree/chromium/TestShell.h

    r141237 r141596  
    3434#include "NotificationPresenter.h"
    3535#include "TestEventPrinter.h"
    36 #include "TestRunner/src/TestRunner.h"
    3736#include "WebPreferences.h"
    3837#include "WebTestInterfaces.h"
    … …  
    8584    // Returns the host for the main WebView.
    8685    WebViewHost* webViewHost() const { return m_webViewHost.get(); }
    87     WebTestRunner::WebTestRunner* testRunner() const { return m_testRunner.get(); }
     86    WebTestRunner::WebTestRunner* testRunner() const { return m_testInterfaces->testRunner(); }
    8887    WebTestRunner::WebEventSender* eventSender() const { return m_testInterfaces->eventSender(); }
    8988    WebTestRunner::WebAccessibilityController* accessibilityController() const { return m_testInterfaces->accessibilityController(); }
    … …  
    109108
    110109    void setFocus(WebKit::WebWidget*, bool enable);
    111     bool shouldDumpResourceRequestCallbacks() const { return (m_testIsPreparing || m_testIsPending) && testRunner()->shouldDumpResourceRequestCallbacks(); }
    112     bool shouldDumpResourceLoadCallbacks() const  { return (m_testIsPreparing || m_testIsPending) && testRunner()->shouldDumpResourceLoadCallbacks(); }
    113     bool shouldDumpResourceResponseMIMETypes() const  { return (m_testIsPreparing || m_testIsPending) && testRunner()->shouldDumpResourceResponseMIMETypes(); }
    114110
    115111    // Called by the DRTTestRunner to signal test completion.
    116     void testFinished();
     112    void testFinished(WebViewHost*);
    117113    // Called by DRTTestRunner when a test hits the timeout, but does not
    118114    // cause a hang. We can avoid killing TestShell in this case and still dump
    … …  
    210206    OwnPtr<WebTestRunner::WebTestInterfaces> m_testInterfaces;
    211207    OwnPtr<WebTestRunner::WebTestInterfaces> m_devToolsTestInterfaces;
    212     OwnPtr<WebTestRunner::TestRunner> m_testRunner;
    213208#if ENABLE(NOTIFICATIONS) || ENABLE(LEGACY_NOTIFICATIONS)
    214209    OwnPtr<NotificationPresenter> m_notificationPresenter;

  • trunk/Tools/DumpRenderTree/chromium/WebViewHost.cpp

    r141512 r141596  
    914914void WebViewHost::testFinished()
    915915{
    916     m_shell->testFinished();
     916    m_shell->testFinished(this);
    917917}
    918918
Note: See TracChangeset for help on using the changeset viewer.