Changeset 18765 in webkit

Timestamp:

Jan 11, 2007 4:34:26 AM (17 years ago)

Author:

lars

Message:

Start using the loader in the Qt port.

Location:

trunk

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/loader/FrameLoader.cpp (modified) (5 diffs)
• WebCore/loader/qt/FrameLoaderQt.cpp (modified) (5 diffs)
• WebCore/page/qt/FrameQtClient.cpp (modified) (1 diff)
• WebKitQt/ChangeLog (modified) (1 diff)
• WebKitQt/QtLauncher/main.cpp (modified) (1 diff)
• WebKitQt/WebCoreSupport/FrameLoaderClientQt.cpp (modified) (26 diffs)
• WebKitQt/WebCoreSupport/FrameLoaderClientQt.h (modified) (4 diffs)
• WebKitTools/ChangeLog (modified) (1 diff)
• WebKitTools/DumpRenderTree/DumpRenderTree.qtproj/DumpRenderTree.cpp (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2007-01-11  Lars Knoll <lars@trolltech.com>
+
+        Reviewed by Darin.
+
+        Start using the loader in the Qt port.
+
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::clear):
+        (WebCore::FrameLoader::URL):
+        (WebCore::FrameLoader::createEmptyDocument):
+        * loader/qt/FrameLoaderQt.cpp:
+        (WebCore::FrameLoader::setTitle):
+        (WebCore::FrameLoader::originalRequestURL):
+        (WebCore::FrameLoader::referrer):
+        (WebCore::FrameLoader::checkLoadCompleteForThisFrame):
+        * page/qt/FrameQtClient.cpp:
+        (WebCore::FrameQtClient::openURL):
+
 2007-01-11  Darin Adler  <darin@apple.com>
 

trunk/WebCore/loader/FrameLoader.cpp

@@ -719 +719 @@
     m_needsClear = false;
 
-#if !PLATFORM(MAC)
+#if !PLATFORM(MAC) && !PLATFORM(QT)
     // FIXME: Remove this after making other platforms do loading more like Mac.
     detachChildren();
 #endif
-
+    
     if (m_frame->document()) {
         m_frame->document()->cancelParsing();
@@ -2515 +2515 @@
 KURL FrameLoader::URL() const
 {
-#if PLATFORM(QT)
-    if (!activeDocumentLoader())
-        return KURL();
-#endif
     return activeDocumentLoader()->URL();
 }
@@ -2694 +2690 @@
 }
 
-#if PLATFORM(MAC)
+#if PLATFORM(MAC) || PLATFORM(QT)
 void FrameLoader::submitForm(const FrameLoadRequest& request, Event* event)
 {
@@ -2732 +2728 @@
 }
 #endif
-
+    
 String FrameLoader::userAgent() const
 {
@@ -2743 +2739 @@
     // it does nothing if we already have a document, and just creates an
     // empty one if we have no document at all.
-#if PLATFORM(MAC)
+#if PLATFORM(MAC) || PLATFORM(QT)
     if (!m_frame->document()) {
         loadEmptyDocumentSynchronously();
         updateBaseURLForEmptyDocument();
-    }
-#elif PLATFORM(QT)
-    if (!m_frame->document()) {
-        begin();
-        end();
     }
 #endif

trunk/WebCore/loader/qt/FrameLoaderQt.cpp

@@ -53 +53 @@
 #include "HTMLElement.h"
 #include "HTMLFormElement.h"
+#include "HistoryItem.h"
 #include "JSLock.h"
 #include "MouseEventWithHitTestResults.h"
@@ -79 +80 @@
 namespace WebCore {
 
-void FrameLoader::submitForm(const FrameLoadRequest& frameLoadRequest, Event*)
-{
-#ifdef MULTIPLE_FORM_SUBMISSION_PROTECTION
-    // FIXME: We'd like to remove this altogether and fix the multiple form submission issue another way.
-    // We do not want to submit more than one form from the same page,
-    // nor do we want to submit a single form more than once.
-    // This flag prevents these from happening; not sure how other browsers prevent this.
-    // The flag is reset in each time we start handle a new mouse or key down event, and
-    // also in setView since this part may get reused for a page from the back/forward cache.
-    // The form multi-submit logic here is only needed when we are submitting a form that affects this frame.
-    // FIXME: Frame targeting is only one of the ways the submission could end up doing something other
-    // than replacing this frame's content, so this check is flawed. On the other hand, the check is hardly
-    // needed any more now that we reset m_submittedFormURL on each mouse or key down event.
-    Frame* target = m_frame->tree()->find(frameLoadRequest.frameName());
-    if (m_frame->tree()->isDescendantOf(target)) {
-        if (m_submittedFormURL == frameLoadRequest.resourceRequest().url())
-            return;
-        m_submittedFormURL = frameLoadRequest.resourceRequest().url();
-    }
-#endif
-
-    RefPtr<FormData> formData = frameLoadRequest.resourceRequest().httpBody();
-    if (formData && !formData->isEmpty() && QtFrame(m_frame)->client())
-        QtFrame(m_frame)->client()->submitForm(frameLoadRequest.resourceRequest().httpMethod(),
-                                               frameLoadRequest.resourceRequest().url(),
-                                               formData);
-
-    clearRecordedFormValues();
-}
-
-void FrameLoader::urlSelected(const FrameLoadRequest& frameLoadRequest, Event*)
-{
-    const ResourceRequest& request = frameLoadRequest.resourceRequest();
-
-    if (!QtFrame(m_frame)->client())
-        return;
-
-    QtFrame(m_frame)->client()->openURL(request.url());
-}
 
 void FrameLoader::setTitle(const String& title)
 {
-    client()->setTitle(title, URL());
+    documentLoader()->setTitle(title);
 }
 
@@ -150 +112 @@
 KURL FrameLoader::originalRequestURL() const
 {
-    notImplemented();
-    return KURL();
+    return activeDocumentLoader()->initialRequest().url();
 }
 
@@ -162 +123 @@
 String FrameLoader::referrer() const
 {
-    notImplemented();
-    return String();
+    return documentLoader()->request().httpReferrer();
 }
 
@@ -171 +131 @@
 {
     ASSERT(m_client->hasWebView());
-    //notImplemented();
 
     switch (m_state) {
-    case FrameStateProvisional: {
+        case FrameStateProvisional: {
+            if (m_delegateIsHandlingProvisionalLoadError)
+                return;
+
+            RefPtr<DocumentLoader> pdl = m_provisionalDocumentLoader;
+            if (!pdl)
+                return;
+                
+            // If we've received any errors we may be stuck in the provisional state and actually complete.
+            const ResourceError& error = pdl->mainDocumentError();
+            if (error.isNull())
+                return;
+
+            // Check all children first.
+            RefPtr<HistoryItem> item;
+            if (isBackForwardLoadType(loadType()) && m_frame == m_frame->page()->mainFrame())
+                item = m_currentHistoryItem;
+                
+            bool shouldReset = true;
+            if (!pdl->isLoadingInAPISense()) {
+                m_delegateIsHandlingProvisionalLoadError = true;
+                m_client->dispatchDidFailProvisionalLoad(error);
+                m_delegateIsHandlingProvisionalLoadError = false;
+
+                // FIXME: can stopping loading here possibly have any effect, if isLoading is false,
+                // which it must be to be in this branch of the if? And is it OK to just do a full-on
+                // stopAllLoaders instead of stopLoadingSubframes?
+                stopLoadingSubframes();
+                pdl->stopLoading();
+
+                // Finish resetting the load state, but only if another load hasn't been started by the
+                // delegate callback.
+                if (pdl == m_provisionalDocumentLoader)
+                    clearProvisionalLoad();
+                else if (m_documentLoader) {
+                    KURL unreachableURL = m_documentLoader->unreachableURL();
+                    if (!unreachableURL.isEmpty() && unreachableURL == pdl->request().url())
+                        shouldReset = false;
+                }
+            }
+            if (shouldReset && item && m_frame->page())
+                 m_frame->page()->backForwardList()->goToItem(item.get());
+
+            return;
+        }
+        
+        case FrameStateCommittedPage: {
+            DocumentLoader* dl = m_documentLoader.get();            
+            if (dl->isLoadingInAPISense())
+                return;
+
+            markLoadComplete();
+
+            // FIXME: Is this subsequent work important if we already navigated away?
+            // Maybe there are bugs because of that, or extra work we can skip because
+            // the new page is ready.
+
+            m_client->forceLayoutForNonHTML();
+             
+            // If the user had a scroll point, scroll to it, overriding the anchor point if any.
+            if ((isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload)
+                    && m_frame->page() && m_frame->page()->backForwardList())
+                restoreScrollPositionAndViewState();
+
+            const ResourceError& error = dl->mainDocumentError();
+            if (!error.isNull())
+                m_client->dispatchDidFailLoad(error);
+            else
+                m_client->dispatchDidFinishLoad();
+
+            m_client->progressCompleted();
+            return;
+        }
+        
+        case FrameStateComplete:
+            // Even if already complete, we might have set a previous item on a frame that
+            // didn't do any data loading on the past transaction. Make sure to clear these out.
+            m_client->frameLoadCompleted();
+            return;
     }
 
-    case FrameStateCommittedPage: {
-        DocumentLoader* dl = m_documentLoader.get();
-        if (!dl || dl->isLoadingInAPISense())
-            return;
-
-        markLoadComplete();
-
-        // FIXME: Is this subsequent work important if we already navigated away?
-        // Maybe there are bugs because of that, or extra work we can skip because
-        // the new page is ready.
-
-        m_client->forceLayoutForNonHTML();
-             
-        // If the user had a scroll point, scroll to it, overriding the anchor point if any.
-//         if ((isBackForwardLoadType(m_loadType) || m_loadType == FrameLoadTypeReload)
-//             && m_client->hasBackForwardList())
-//             m_client->restoreScrollPositionAndViewState();
-
-//         if (error)
-//             m_client->dispatchDidFailLoad(error);
-//         else
-            m_client->dispatchDidFinishLoad();
-            
-        m_client->progressCompleted();
-        return;
-    }
-        
-    case FrameStateComplete:
-        // Even if already complete, we might have set a previous item on a frame that
-        // didn't do any data loading on the past transaction. Make sure to clear these out.
-        m_client->frameLoadCompleted();
-        return;
-    }
-
+    ASSERT_NOT_REACHED();
 }
 

trunk/WebCore/page/qt/FrameQtClient.cpp

@@ -73 +73 @@
     ASSERT(m_frame);
 
-//     m_frame->loader()->load(url);
-    m_frame->loader()->didOpenURL(url);
-
-    if (!m_frame->document()) {
-        m_frame->loader()->createEmptyDocument();
-        m_frame->loader()->didOpenURL(url);
-    }
-
-
-    ASSERT(m_frame->document());
-
-    ResourceRequest request(url);
-    RefPtr<ResourceHandle> loader = ResourceHandle::create(request, this, m_frame, false);
-    loader.get()->ref();
+    m_frame->loader()->load(url);
 }
 

trunk/WebKitQt/ChangeLog

@@ +1 @@
+2007-01-11  Lars Knoll <lars@trolltech.com>
+
+        Reviewed by Darin
+
+        Start using the loader in the Qt port.
+
+        * QtLauncher/main.cpp:
+        (main):
+        * WebCoreSupport/FrameLoaderClientQt.cpp:
+        (WebCore::FrameLoaderClientQt::FrameLoaderClientQt):
+        (WebCore::FrameLoaderClientQt::~FrameLoaderClientQt):
+        (WebCore::FrameLoaderClientQt::setFrame):
+        (WebCore::FrameLoaderClientQt::detachFrameLoader):
+        (WebCore::FrameLoaderClientQt::makeDocumentView):
+        (WebCore::FrameLoaderClientQt::makeRepresentation):
+        (WebCore::FrameLoaderClientQt::setCopiesOnScroll):
+        (WebCore::FrameLoaderClientQt::dispatchDidStartProvisionalLoad):
+        (WebCore::FrameLoaderClientQt::cancelPolicyCheck):
+        (WebCore::FrameLoaderClientQt::dispatchWillSubmitForm):
+        (WebCore::FrameLoaderClientQt::progressStarted):
+        (WebCore::FrameLoaderClientQt::progressCompleted):
+        (WebCore::FrameLoaderClientQt::setMainFrameDocumentReady):
+        (WebCore::FrameLoaderClientQt::clearArchivedResources):
+        (WebCore::FrameLoaderClientQt::canShowMIMEType):
+        (WebCore::FrameLoaderClientQt::representationExistsForURLScheme):
+        (WebCore::FrameLoaderClientQt::provisionalLoadStarted):
+        (WebCore::FrameLoaderClientQt::prepareForDataSourceReplacement):
+        (WebCore::FrameLoaderClientQt::frameLoaderDestroyed):
+        (WebCore::FrameLoaderClientQt::canHandleRequest):
+        (WebCore::FrameLoaderClientQt::shouldGoToHistoryItem):
+        (WebCore::FrameLoaderClientQt::canCachePage):
+        (WebCore::FrameLoaderClientQt::committedLoad):
+        (WebCore::FrameLoaderClientQt::cancelledError):
+        (WebCore::FrameLoaderClientQt::cannotShowURLError):
+        (WebCore::FrameLoaderClientQt::interruptForPolicyChangeError):
+        (WebCore::FrameLoaderClientQt::cannotShowMIMETypeError):
+        (WebCore::FrameLoaderClientQt::fileDoesNotExistError):
+        (WebCore::FrameLoaderClientQt::shouldFallBack):
+        (WebCore::FrameLoaderClientQt::createDocumentLoader):
+        (WebCore::FrameLoaderClientQt::dispatchWillSendRequest):
+        (WebCore::FrameLoaderClientQt::dispatchDidReceiveResponse):
+        (WebCore::FrameLoaderClientQt::dispatchDecidePolicyForMIMEType):
+        (WebCore::FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction):
+        (WebCore::FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction):
+        (WebCore::FrameLoaderClientQt::willUseArchive):
+        * WebCoreSupport/FrameLoaderClientQt.h:
+
 2007-01-11  George Staikos  <staikos@kde.org>
 

trunk/WebKitQt/QtLauncher/main.cpp

@@ -89 +89 @@
     Page* page = new Page(new ChromeClientQt(), new ContextMenuClientQt(),
                           new EditorClientQt());
-    Frame* frame = new FrameQt(page, 0, new FrameQtClient(), new FrameLoaderClientQt());
+    FrameLoaderClientQt *frameLoaderClient = new FrameLoaderClientQt();
+    FrameQt* frame = new FrameQt(page, 0, new FrameQtClient(), frameLoaderClient);
+    frameLoaderClient->setFrame(frame);
 
     FrameView* frameView = new FrameView(frame);

trunk/WebKitQt/WebCoreSupport/FrameLoaderClientQt.cpp

@@ -30 +30 @@
 #include "FrameLoaderClientQt.h"
 #include "DocumentLoader.h"
+#include "ResourceResponse.h"
+#include "qdebug.h"
 
 #define notImplemented() do { fprintf(stderr, "FIXME: UNIMPLEMENTED: %s:%d (%s)\n", __FILE__, __LINE__, __FUNCTION__); } while(0)
 
+
 namespace WebCore
 {
 
 FrameLoaderClientQt::FrameLoaderClientQt()
-{
-    notImplemented();
+    : m_frame(0)
+{
 }
 
@@ -44 +47 @@
 FrameLoaderClientQt::~FrameLoaderClientQt()
 {
-    notImplemented();
-}
-
+}
+
+void FrameLoaderClientQt::setFrame(FrameQt *frame)
+{
+    m_frame = frame;
+}
 
 void FrameLoaderClientQt::detachFrameLoader()
 {
-    notImplemented();
+    m_frame = 0;
 }
 
@@ -119 +125 @@
 void FrameLoaderClientQt::makeDocumentView()
 {
-    notImplemented();
+    qDebug() << "FrameLoaderClientQt::makeDocumentView" << m_frame->document();
+    
+//     if (!m_frame->document()) 
+//         m_frame->loader()->createEmptyDocument();
 }
 
@@ -125 +134 @@
 void FrameLoaderClientQt::makeRepresentation(DocumentLoader*)
 {
-    notImplemented();
+    // don't need this for now I think.
 }
 
@@ -179 +188 @@
 void FrameLoaderClientQt::setCopiesOnScroll()
 {
-    notImplemented();
+    // apparently mac specific 
 }
 
@@ -278 +287 @@
 void FrameLoaderClientQt::dispatchDidStartProvisionalLoad()
 {
-    notImplemented();
+    // we're not interested in this neither I think
 }
 
@@ -314 +323 @@
 void FrameLoaderClientQt::cancelPolicyCheck()
 {
-    notImplemented();
-}
-
-
-void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction,
+    // don't need to do anything here as long as we don't start doing asyncronous policy checks
+}
+
+
+void FrameLoaderClientQt::dispatchWillSubmitForm(FramePolicyFunction function,
                                                  PassRefPtr<FormState>)
 {
-    notImplemented();
+    // FIXME: This is surely too simple
+    if (!m_frame)
+        return;
+    (m_frame->loader()->*function)(PolicyUse);
 }
 
@@ -358 +370 @@
 void FrameLoaderClientQt::progressStarted()
 {
-    notImplemented();
+    // no progress notification for now
 }
 
@@ -364 +376 @@
 void FrameLoaderClientQt::progressCompleted()
 {
-    notImplemented();
-}
-
-
-void FrameLoaderClientQt::setMainFrameDocumentReady(bool)
-{
-    notImplemented();
+    // no progress notification for now
+}
+
+
+void FrameLoaderClientQt::setMainFrameDocumentReady(bool b)
+{
+    // this is only interesting once we provide an external API for the DOM
 }
 
@@ -419 +431 @@
 void FrameLoaderClientQt::clearArchivedResources()
 {
-    notImplemented();
+    // don't think we need to do anything here currently
 }
 
@@ -425 +437 @@
 bool FrameLoaderClientQt::canShowMIMEType(const String& MIMEType) const
 {
-    notImplemented();
-    return false;
-}
-
-
-bool FrameLoaderClientQt::representationExistsForURLScheme(
-    const String& URLScheme) const
-{
-    notImplemented();
+    // FIXME: This is not good enough in the general case
+    qDebug() << "FrameLoaderClientQt::canShowMIMEType" << MIMEType;
+    return true;
+}
+
+
+bool FrameLoaderClientQt::representationExistsForURLScheme(const String& URLScheme) const
+{
+    notImplemented();
+    qDebug() << "    scheme is" << URLScheme;
     return false;
 }
@@ -459 +472 @@
 void FrameLoaderClientQt::provisionalLoadStarted()
 {
-    notImplemented();
+    // don't need to do anything here
 }
 
@@ -484 +497 @@
 void FrameLoaderClientQt::prepareForDataSourceReplacement()
 {
-    notImplemented();
+    m_frame->loader()->detachChildren();
 }
 
@@ -506 +519 @@
 void FrameLoaderClientQt::frameLoaderDestroyed()
 {
-    notImplemented();
+    m_frame = 0;
+    delete this;
 }
 
 bool FrameLoaderClientQt::canHandleRequest(const WebCore::ResourceRequest&) const
 {
-    notImplemented();
+    return true;
 }
 
@@ -537 +551 @@
 {
     notImplemented();
+    return false;
 }
 
@@ -551 +566 @@
 bool FrameLoaderClientQt::canCachePage() const
 {
-    notImplemented();
+    // don't do any caching for now
+    return false;
 }
 
@@ -559 +575 @@
 }
 
-void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader*, const char*, int)
-{
-    notImplemented();
+void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
+{
+    qDebug() << "FrameLoaderClientQt::committedLoad" << length;
+    if (!m_frame)
+        return;
+    FrameLoader *fl = loader->frameLoader();
+    fl->setEncoding(m_response.textEncodingName(), false);
+    fl->addData(data, length);
 }
 
@@ -567 +588 @@
 {
     notImplemented();
+    return ResourceError();
 }
 
@@ -572 +594 @@
 {
     notImplemented();
+    return ResourceError();
 }
 
@@ -577 +600 @@
 {
     notImplemented();
+    return ResourceError();
 }
 
@@ -582 +606 @@
 {
     notImplemented();
+    return ResourceError();
 }
 
@@ -587 +612 @@
 {
     notImplemented();
+    return ResourceError();
 }
 
@@ -592 +618 @@
 {
     notImplemented();
-}
-
-WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest&)
-{
-    notImplemented();
+    return false;
+}
+
+WTF::PassRefPtr<WebCore::DocumentLoader> FrameLoaderClientQt::createDocumentLoader(const WebCore::ResourceRequest& request)
+{
+    RefPtr<DocumentLoader> loader = new DocumentLoader(request);
+    return loader.release();
 }
 
@@ -604 +632 @@
 }
 
-void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, void*, WebCore::ResourceRequest&, const WebCore::ResourceResponse&)
-{
-    notImplemented();
-}
-
-void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, void*, const WebCore::ResourceResponse&)
-{
-    notImplemented();
+void FrameLoaderClientQt::dispatchWillSendRequest(WebCore::DocumentLoader*, void*, WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response)
+{
+    // seems like the Mac code doesn't do anything here by default neither
+    qDebug() << "FrameLoaderClientQt::dispatchWillSendRequest" << request.isNull() << request.url().url();
+}
+
+void FrameLoaderClientQt::dispatchDidReceiveResponse(WebCore::DocumentLoader*, void*, const WebCore::ResourceResponse& response)
+{
+
+    m_response = response;
+    m_firstData = true;
+    qDebug() << "    got response from" << response.url().url();
 }
 
@@ -649 +681 @@
 }
 
-void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::String&, const WebCore::ResourceRequest&)
-{
-    notImplemented();
-}
-
-void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
-{
-    notImplemented();
-}
-
-void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::NavigationAction&, const WebCore::ResourceRequest&)
-{
-    notImplemented();
+void FrameLoaderClientQt::dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&)
+{
+    if (!m_frame)
+        return;
+    // FIXME: This is maybe too simple
+    (m_frame->loader()->*function)(PolicyUse);
+}
+
+void FrameLoaderClientQt::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&)
+{
+    if (!m_frame)
+        return;
+    // FIXME: This is maybe too simple
+    (m_frame->loader()->*function)(PolicyIgnore);
+}
+
+void FrameLoaderClientQt::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&)
+{
+    if (!m_frame)
+        return;
+    // FIXME: This is maybe too simple
+    (m_frame->loader()->*function)(PolicyUse);
 }
 
@@ -692 +733 @@
 {
     notImplemented();
-}
-
-
-}
-
-
+    return false;
+}
+
+
+}
+
+

trunk/WebKitQt/WebCoreSupport/FrameLoaderClientQt.h

@@ -34 +34 @@
 #include "FrameLoader.h"
 #include "Shared.h"
+#include "ResourceResponse.h"
 
 namespace WebCore {
@@ -50 +51 @@
         FrameLoaderClientQt();
         ~FrameLoaderClientQt();
+        void setFrame(FrameQt *frame);
         virtual void detachFrameLoader();
 
@@ -179 +181 @@
         virtual void dispatchDidFailLoad(const WebCore::ResourceError&);
         virtual WebCore::Frame* dispatchCreatePage();
-        virtual void dispatchDecidePolicyForMIMEType(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::String&, const WebCore::ResourceRequest&);
-        virtual void dispatchDecidePolicyForNewWindowAction(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&);
-        virtual void dispatchDecidePolicyForNavigationAction(void (WebCore::FrameLoader::*)(WebCore::PolicyAction), const WebCore::NavigationAction&, const WebCore::ResourceRequest&);
+        virtual void dispatchDecidePolicyForMIMEType(FramePolicyFunction function, const WebCore::String&, const WebCore::ResourceRequest&);
+        virtual void dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&, const WebCore::String&);
+        virtual void dispatchDecidePolicyForNavigationAction(FramePolicyFunction function, const WebCore::NavigationAction&, const WebCore::ResourceRequest&);
         virtual void dispatchUnableToImplementPolicy(const WebCore::ResourceError&);
         virtual void incrementProgress(void*, const WebCore::ResourceResponse&);
@@ -191 +193 @@
         // FIXME: This should probably not be here, but it's needed for the tests currently
         virtual void partClearedInBegin();
-        
+
+
+    private:
+        Frame *m_frame;
+        ResourceResponse m_response;
+        bool m_firstData;
     };
 

trunk/WebKitTools/ChangeLog

@@ +1 @@
+2007-01-11  Lars Knoll <lars@trolltech.com>
+
+        Reviewed by Darin.
+
+        Adjust to loader changes.
+
+        * DumpRenderTree/DumpRenderTree.qtproj/DumpRenderTree.cpp:
+        (WebCore::DumpRenderTree::DumpRenderTree):
+
 2007-01-06  George Staikos  <staikos@kde.org>
 

trunk/WebKitTools/DumpRenderTree/DumpRenderTree.qtproj/DumpRenderTree.cpp

@@ -79 +79 @@
     Page* page = new Page(new ChromeClientQt(), new ContextMenuClientQt(), new EditorClientQt());
     m_frame = new FrameQt(page, 0, new FrameQtClient(), m_client);
+    m_client->setFrame(m_frame);
 
     FrameView* view = new FrameView(m_frame);