Source/WebKit/haiku/WebCoreSupport/FrameLoaderClientHaiku.cpp - platform/external/webkit - Git at Google

 /*
  * Copyright (C) 2006 Don Gibson <dgibson77@gmail.com>
  * Copyright (C) 2006 Zack Rusin <zack@kde.org>
  * Copyright (C) 2006, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Trolltech ASA
  * Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> All rights reserved.
  * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com> All rights reserved.
  *
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "FrameLoaderClientHaiku.h"

 #include "DocumentLoader.h"
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "FrameTree.h"
 #include "FrameView.h"
 #include "HTMLFrameOwnerElement.h"
 #include "NotImplemented.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "ResourceRequest.h"
 #include "ScriptController.h"
 #include "WebView.h"

 #include <Message.h>
 #include <String.h>

 #include <app/Messenger.h>


 namespace WebCore {

 FrameLoaderClientHaiku::FrameLoaderClientHaiku()
     : m_frame(0)
 {
 }

 void FrameLoaderClientHaiku::setFrame(Frame* frame)
 {
     m_frame = frame;
 }

 void FrameLoaderClientHaiku::setWebView(WebView* webview)
 {
     m_webView = webview;
     m_messenger = new BMessenger(m_webView);
     ASSERT(m_messenger->IsValid());
 }

 void FrameLoaderClientHaiku::detachFrameLoader()
 {
     m_frame = 0;
 }

 bool FrameLoaderClientHaiku::hasWebView() const
 {
     return m_webView;
 }

 bool FrameLoaderClientHaiku::hasBackForwardList() const
 {
     notImplemented();
     return true;
 }

 void FrameLoaderClientHaiku::resetBackForwardList()
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::provisionalItemIsTarget() const
 {
     notImplemented();
     return false;
 }

 void FrameLoaderClientHaiku::makeRepresentation(DocumentLoader*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::forceLayout()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::forceLayoutForNonHTML()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryForCommit()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryForBackForwardNavigation()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryForReload()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryForStandardLoad()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryForInternalLoad()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateHistoryAfterClientRedirect()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::setCopiesOnScroll()
 {
     // apparently mac specific
     notImplemented();
 }

 LoadErrorResetToken* FrameLoaderClientHaiku::tokenForLoadErrorReset()
 {
     notImplemented();
     return 0;
 }

 void FrameLoaderClientHaiku::resetAfterLoadError(LoadErrorResetToken*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::doNotResetAfterLoadError(LoadErrorResetToken*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::willCloseDocument()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::detachedFromParent2()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::detachedFromParent3()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidHandleOnloadEvents()
 {
     if (m_webView) {
         BMessage message(LOAD_ONLOAD_HANDLE);
         message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveServerRedirectForProvisionalLoad()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidCancelClientRedirect()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidChangeLocationWithinPage()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidPushStateWithinPage()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidReplaceStateWithinPage()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidPopStateWithinPage()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchWillClose()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidStartProvisionalLoad()
 {
     if (m_webView) {
         BMessage message(LOAD_NEGOCIATING);
         message.AddString("url", m_frame->loader()->provisionalDocumentLoader()->request().url().string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveTitle(const StringWithTitle& title)
 {
     if (m_webView) {
         // FIXME: use direction of title.
         m_webView->SetPageTitle(title.m_string());
         BMessage message(TITLE_CHANGED);
         message.AddString("title", title.string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::dispatchDidCommitLoad()
 {
     if (m_webView) {
         BMessage message(LOAD_TRANSFERRING);
         message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::dispatchDidFinishDocumentLoad()
 {
     if (m_webView) {
         BMessage message(LOAD_DOC_COMPLETED);
         message.AddString("url", m_frame->document()->url().string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::dispatchDidFinishLoad()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidFirstLayout()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidFirstVisuallyNonEmptyLayout()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchShow()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::cancelPolicyCheck()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState>)
 {
     // FIXME: Send an event to allow for alerts and cancellation.
     if (!m_frame)
         return;
     (m_frame->loader()->policyChecker()->*function)(PolicyUse);
 }

 void FrameLoaderClientHaiku::dispatchDidLoadMainResource(DocumentLoader*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::revertToProvisionalState(DocumentLoader*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::postProgressStartedNotification()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::postProgressEstimateChangedNotification()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::postProgressFinishedNotification()
 {
     if (m_webView) {
         BMessage message(LOAD_DL_COMPLETED);
         message.AddString("url", m_frame->document()->url().string());
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::progressStarted()
 {
     notImplemented();
 }


 void FrameLoaderClientHaiku::progressCompleted()
 {
     notImplemented();
 }


 void FrameLoaderClientHaiku::setMainFrameDocumentReady(bool)
 {
     notImplemented();
     // this is only interesting once we provide an external API for the DOM
 }

 void FrameLoaderClientHaiku::willChangeTitle(DocumentLoader*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::didChangeTitle(DocumentLoader* docLoader)
 {
     setTitle(docLoader->title(), docLoader->url());
 }

 void FrameLoaderClientHaiku::finishedLoading(DocumentLoader*)
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::canShowMIMETypeAsHTML(const String& MIMEType) const
 {
     notImplemented();
     return false;
 }

 bool FrameLoaderClientHaiku::canShowMIMEType(const String& MIMEType) const
 {
     notImplemented();
     return true;
 }

 bool FrameLoaderClientHaiku::representationExistsForURLScheme(const String& URLScheme) const
 {
     notImplemented();
     return false;
 }

 String FrameLoaderClientHaiku::generatedMIMETypeForURLScheme(const String& URLScheme) const
 {
     notImplemented();
     return String();
 }

 void FrameLoaderClientHaiku::frameLoadCompleted()
 {
     if (m_webView->LockLooper()) {
         m_webView->Draw(m_webView->Bounds());
         m_webView->UnlockLooper();
     }
 }

 void FrameLoaderClientHaiku::saveViewStateToItem(HistoryItem*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::restoreViewState()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::restoreScrollPositionAndViewState()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::provisionalLoadStarted()
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::shouldTreatURLAsSameAsCurrent(const KURL&) const
 {
     notImplemented();
     return false;
 }

 void FrameLoaderClientHaiku::addHistoryItemForFragmentScroll()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::didFinishLoad()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::prepareForDataSourceReplacement()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::setTitle(const String& title, const KURL&)
 {
     notImplemented();
 }

 String FrameLoaderClientHaiku::userAgent(const KURL&)
 {
     return String("Mozilla/5.0 (compatible; U; InfiNet 0.1; Haiku) AppleWebKit/420+ (KHTML, like Gecko)");
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveIcon()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::frameLoaderDestroyed()
 {
     m_frame = 0;
     m_messenger = 0;
     delete this;
 }

 bool FrameLoaderClientHaiku::canHandleRequest(const WebCore::ResourceRequest&) const
 {
     notImplemented();
     return true;
 }

 void FrameLoaderClientHaiku::partClearedInBegin()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateGlobalHistory()
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::updateGlobalHistoryRedirectLinks()
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::shouldGoToHistoryItem(WebCore::HistoryItem*) const
 {
     notImplemented();
     return true;
 }

 bool FrameLoaderClientHaiku::shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const
 {
     return true;
 }

 void FrameLoaderClientHaiku::dispatchDidAddBackForwardItem(WebCore::HistoryItem*) const
 {
 }

 void FrameLoaderClientHaiku::dispatchDidRemoveBackForwardItem(WebCore::HistoryItem*) const
 {
 }

 void FrameLoaderClientHaiku::dispatchDidChangeBackForwardIndex() const
 {
 }

 void FrameLoaderClientHaiku::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::canCachePage() const
 {
     return false;
 }

 void FrameLoaderClientHaiku::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
 {
     loader->commitData(data, length);
 }

 WebCore::ResourceError FrameLoaderClientHaiku::cancelledError(const WebCore::ResourceRequest& request)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
 }

 WebCore::ResourceError FrameLoaderClientHaiku::blockedError(const ResourceRequest& request)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
 }

 WebCore::ResourceError FrameLoaderClientHaiku::cannotShowURLError(const WebCore::ResourceRequest& request)
 {
     return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
 }

 WebCore::ResourceError FrameLoaderClientHaiku::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(), String());
 }

 WebCore::ResourceError FrameLoaderClientHaiku::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url().string(), String());
 }

 WebCore::ResourceError FrameLoaderClientHaiku::fileDoesNotExistError(const WebCore::ResourceResponse& response)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorCannotShowURL, response.url().string(), String());
 }

 bool FrameLoaderClientHaiku::shouldFallBack(const WebCore::ResourceError& error)
 {
     notImplemented();
     return false;
 }

 WTF::PassRefPtr<DocumentLoader> FrameLoaderClientHaiku::createDocumentLoader(const ResourceRequest& request,
                                                                              const SubstituteData& substituteData)
 {
     return DocumentLoader::create(request, substituteData);
 }

 void FrameLoaderClientHaiku::download(ResourceHandle*, const ResourceRequest&,
                                       const ResourceRequest&, const ResourceResponse&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*,
                                                               const ResourceRequest&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request,
                                                      const ResourceResponse& response)
 {
     notImplemented();
 }

 bool FrameLoaderClientHaiku::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
 {
     notImplemented();
     return false;
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*,
                                                                        unsigned long, const AuthenticationChallenge&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidCancelAuthenticationChallenge(DocumentLoader*,
                                                                       unsigned long, const AuthenticationChallenge&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id,
                                                         const ResourceResponse& response)
 {
     notImplemented();
     m_response = response;
     m_firstData = true;
 }

 void FrameLoaderClientHaiku::dispatchDidReceiveContentLength(DocumentLoader* loader,
                                                              unsigned long id, int length)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidFailLoading(DocumentLoader* loader,
                                                     unsigned long, const ResourceError&)
 {
     if (m_webView) {
         BMessage message(LOAD_FAILED);
         message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
         m_messenger->SendMessage(&message);
     }
 }

 bool FrameLoaderClientHaiku::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*,
                                                                     const ResourceRequest&,
                                                                     const ResourceResponse&, int)
 {
     notImplemented();
     return false;
 }

 void FrameLoaderClientHaiku::dispatchDidFailProvisionalLoad(const ResourceError&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::dispatchDidFailLoad(const ResourceError&)
 {
     notImplemented();
 }

 Frame* FrameLoaderClientHaiku::dispatchCreatePage(const WebCore::NavigationAction&)
 {
     notImplemented();
     return false;
 }

 void FrameLoaderClientHaiku::dispatchDecidePolicyForResponse(FramePolicyFunction function,
                                                              const ResourceResponse& response,
                                                              const ResourceRequest& request)
 {
     if (!m_frame)
         return;

     notImplemented();
     (m_frame->loader()->policyChecker()->*function)(PolicyUse);
 }

 void FrameLoaderClientHaiku::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function,
                                                                     const NavigationAction&,
                                                                     const ResourceRequest& request,
                                                                     PassRefPtr<FormState>, const String& targetName)
 {
     if (!m_frame)
         return;

     if (m_webView) {
         BMessage message(NEW_WINDOW_REQUESTED);
         message.AddString("url", request.url().string());
         if (m_messenger->SendMessage(&message)) {
             (m_frame->loader()->policyChecker()->*function)(PolicyIgnore);
             return;
         }
     }

     (m_frame->loader()->policyChecker()->*function)(PolicyUse);
 }

 void FrameLoaderClientHaiku::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function,
                                                                      const NavigationAction& action,
                                                                      const ResourceRequest& request,
                                                                      PassRefPtr<FormState>)
 {
     if (!m_frame || !function)
         return;

     if (m_webView) {
         BMessage message(NAVIGATION_REQUESTED);
         message.AddString("url", request.url().string());
         m_messenger->SendMessage(&message);

         (m_frame->loader()->policyChecker()->*function)(PolicyUse);
     }
 }

 void FrameLoaderClientHaiku::dispatchUnableToImplementPolicy(const ResourceError&)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::startDownload(const ResourceRequest&)
 {
     notImplemented();
 }

 PassRefPtr<Frame> FrameLoaderClientHaiku::createFrame(const KURL& url, const String& name,
                                                       HTMLFrameOwnerElement* ownerElement,
                                                       const String& referrer, bool allowsScrolling,
                                                       int marginWidth, int marginHeight)
 {
     // FIXME: We should apply the right property to the frameView. (scrollbar,margins)

     RefPtr<Frame> childFrame = Frame::create(m_frame->page(), ownerElement, this);
     setFrame(childFrame.get());

     RefPtr<FrameView> frameView = FrameView::create(childFrame.get());

     frameView->setAllowsScrolling(allowsScrolling);
     frameView->deref();
     childFrame->setView(frameView.get());
     childFrame->init();

     childFrame->tree()->setName(name);
     m_frame->tree()->appendChild(childFrame);

     m_frame->loader()->loadURLIntoChildFrame(url, referrer, childFrame.get());

     // The frame's onload handler may have removed it from the document.
     if (!childFrame->tree()->parent())
         return 0;

     return childFrame.release();

     notImplemented();
     return 0;
 }

 void FrameLoaderClientHaiku::didTransferChildFrameToNewDocument(Page*)
 {
 }

 void FrameLoaderClientHaiku::transferLoadingResourceFromPage(unsigned long, DocumentLoader*, const ResourceRequest&, Page*)
 {
 }

 ObjectContentType FrameLoaderClientHaiku::objectContentType(const KURL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
 {
     notImplemented();
     return ObjectContentType();
 }

 PassRefPtr<Widget> FrameLoaderClientHaiku::createPlugin(const IntSize&, HTMLPlugInElement*,
                                                         const KURL&, const Vector<String>&,
                                                         const Vector<String>&, const String&,
                                                         bool loadManually)
 {
     notImplemented();
     return 0;
 }

 void FrameLoaderClientHaiku::redirectDataToPlugin(Widget* pluginWidget)
 {
     notImplemented();
     return;
 }

 ResourceError FrameLoaderClientHaiku::pluginWillHandleLoadError(const ResourceResponse& response)
 {
     notImplemented();
     return ResourceError(String(), WebKitErrorCannotLoadPlugIn, response.url().string(), String());
 }

 PassRefPtr<Widget> FrameLoaderClientHaiku::createJavaAppletWidget(const IntSize&, HTMLAppletElement*,
                                                        const KURL& baseURL,
                                                        const Vector<String>& paramNames,
                                                        const Vector<String>& paramValues)
 {
     notImplemented();
     return 0;
 }

 String FrameLoaderClientHaiku::overrideMediaType() const
 {
     notImplemented();
     return String();
 }

 void FrameLoaderClientHaiku::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
 {
     if (world != mainThreadNormalWorld())
         return;

     if (m_webView) {
         BMessage message(JAVASCRIPT_WINDOW_OBJECT_CLEARED);
         m_messenger->SendMessage(&message);
     }
 }

 void FrameLoaderClientHaiku::documentElementAvailable()
 {
 }

 void FrameLoaderClientHaiku::didPerformFirstNavigation() const
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::registerForIconNotification(bool listen)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::savePlatformDataToCachedFrame(CachedFrame*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::transitionToCommittedFromCachedFrame(CachedFrame*)
 {
     notImplemented();
 }

 void FrameLoaderClientHaiku::transitionToCommittedForNewPage()
 {
     ASSERT(m_frame);
     ASSERT(m_webView);

     Page* page = m_frame->page();
     ASSERT(page);

     bool isMainFrame = m_frame == page->mainFrame();

     m_frame->setView(0);

     RefPtr<FrameView> frameView;
     if (isMainFrame) {
         if (m_webView->LockLooper()) {
             // We lock the looper in order to get the bounds of the WebView.
             frameView = FrameView::create(m_frame, IntRect(m_webView->Bounds()).size());
             m_webView->UnlockLooper();
         }
     } else
         frameView = FrameView::create(m_frame);

     ASSERT(frameView);
     m_frame->setView(frameView);

     frameView->setPlatformWidget(m_webView);

     if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
         m_frame->view()->setScrollbarModes(owner->scrollingMode(), owner->scrollingMode());
 }

 void FrameLoaderClientHaiku::didSaveToPageCache()
 {
 }

 void FrameLoaderClientHaiku::didRestoreFromPageCache()
 {
 }

 void FrameLoaderClientHaiku::dispatchDidBecomeFrameset(bool)
 {
 }

 } // namespace WebCore
	/*
	* Copyright (C) 2006 Don Gibson <dgibson77@gmail.com>
	* Copyright (C) 2006 Zack Rusin <zack@kde.org>
	* Copyright (C) 2006, 2011 Apple Inc. All rights reserved.
	* Copyright (C) 2007 Trolltech ASA
	* Copyright (C) 2007 Ryan Leavengood <leavengood@gmail.com> All rights reserved.
	* Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com> All rights reserved.
	*
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "FrameLoaderClientHaiku.h"

	#include "DocumentLoader.h"
	#include "Frame.h"
	#include "FrameLoader.h"
	#include "FrameTree.h"
	#include "FrameView.h"
	#include "HTMLFrameOwnerElement.h"
	#include "NotImplemented.h"
	#include "Page.h"
	#include "PlatformString.h"
	#include "ResourceRequest.h"
	#include "ScriptController.h"
	#include "WebView.h"

	#include <Message.h>
	#include <String.h>

	#include <app/Messenger.h>


	namespace WebCore {

	FrameLoaderClientHaiku::FrameLoaderClientHaiku()
	: m_frame(0)
	{
	}

	void FrameLoaderClientHaiku::setFrame(Frame* frame)
	{
	m_frame = frame;
	}

	void FrameLoaderClientHaiku::setWebView(WebView* webview)
	{
	m_webView = webview;
	m_messenger = new BMessenger(m_webView);
	ASSERT(m_messenger->IsValid());
	}

	void FrameLoaderClientHaiku::detachFrameLoader()
	{
	m_frame = 0;
	}

	bool FrameLoaderClientHaiku::hasWebView() const
	{
	return m_webView;
	}

	bool FrameLoaderClientHaiku::hasBackForwardList() const
	{
	notImplemented();
	return true;
	}

	void FrameLoaderClientHaiku::resetBackForwardList()
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::provisionalItemIsTarget() const
	{
	notImplemented();
	return false;
	}

	void FrameLoaderClientHaiku::makeRepresentation(DocumentLoader*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::forceLayout()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::forceLayoutForNonHTML()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryForCommit()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryForBackForwardNavigation()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryForReload()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryForStandardLoad()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryForInternalLoad()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateHistoryAfterClientRedirect()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::setCopiesOnScroll()
	{
	// apparently mac specific
	notImplemented();
	}

	LoadErrorResetToken* FrameLoaderClientHaiku::tokenForLoadErrorReset()
	{
	notImplemented();
	return 0;
	}

	void FrameLoaderClientHaiku::resetAfterLoadError(LoadErrorResetToken*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::doNotResetAfterLoadError(LoadErrorResetToken*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::willCloseDocument()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::detachedFromParent2()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::detachedFromParent3()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidHandleOnloadEvents()
	{
	if (m_webView) {
	BMessage message(LOAD_ONLOAD_HANDLE);
	message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveServerRedirectForProvisionalLoad()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidCancelClientRedirect()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchWillPerformClientRedirect(const KURL&, double interval, double fireDate)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidChangeLocationWithinPage()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidPushStateWithinPage()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidReplaceStateWithinPage()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidPopStateWithinPage()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchWillClose()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidStartProvisionalLoad()
	{
	if (m_webView) {
	BMessage message(LOAD_NEGOCIATING);
	message.AddString("url", m_frame->loader()->provisionalDocumentLoader()->request().url().string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveTitle(const StringWithTitle& title)
	{
	if (m_webView) {
	// FIXME: use direction of title.
	m_webView->SetPageTitle(title.m_string());
	BMessage message(TITLE_CHANGED);
	message.AddString("title", title.string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::dispatchDidCommitLoad()
	{
	if (m_webView) {
	BMessage message(LOAD_TRANSFERRING);
	message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::dispatchDidFinishDocumentLoad()
	{
	if (m_webView) {
	BMessage message(LOAD_DOC_COMPLETED);
	message.AddString("url", m_frame->document()->url().string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::dispatchDidFinishLoad()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidFirstLayout()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidFirstVisuallyNonEmptyLayout()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchShow()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::cancelPolicyCheck()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchWillSubmitForm(FramePolicyFunction function, PassRefPtr<FormState>)
	{
	// FIXME: Send an event to allow for alerts and cancellation.
	if (!m_frame)
	return;
	(m_frame->loader()->policyChecker()->*function)(PolicyUse);
	}

	void FrameLoaderClientHaiku::dispatchDidLoadMainResource(DocumentLoader*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::revertToProvisionalState(DocumentLoader*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::postProgressStartedNotification()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::postProgressEstimateChangedNotification()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::postProgressFinishedNotification()
	{
	if (m_webView) {
	BMessage message(LOAD_DL_COMPLETED);
	message.AddString("url", m_frame->document()->url().string());
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::progressStarted()
	{
	notImplemented();
	}


	void FrameLoaderClientHaiku::progressCompleted()
	{
	notImplemented();
	}


	void FrameLoaderClientHaiku::setMainFrameDocumentReady(bool)
	{
	notImplemented();
	// this is only interesting once we provide an external API for the DOM
	}

	void FrameLoaderClientHaiku::willChangeTitle(DocumentLoader*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::didChangeTitle(DocumentLoader* docLoader)
	{
	setTitle(docLoader->title(), docLoader->url());
	}

	void FrameLoaderClientHaiku::finishedLoading(DocumentLoader*)
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::canShowMIMETypeAsHTML(const String& MIMEType) const
	{
	notImplemented();
	return false;
	}

	bool FrameLoaderClientHaiku::canShowMIMEType(const String& MIMEType) const
	{
	notImplemented();
	return true;
	}

	bool FrameLoaderClientHaiku::representationExistsForURLScheme(const String& URLScheme) const
	{
	notImplemented();
	return false;
	}

	String FrameLoaderClientHaiku::generatedMIMETypeForURLScheme(const String& URLScheme) const
	{
	notImplemented();
	return String();
	}

	void FrameLoaderClientHaiku::frameLoadCompleted()
	{
	if (m_webView->LockLooper()) {
	m_webView->Draw(m_webView->Bounds());
	m_webView->UnlockLooper();
	}
	}

	void FrameLoaderClientHaiku::saveViewStateToItem(HistoryItem*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::restoreViewState()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::restoreScrollPositionAndViewState()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::provisionalLoadStarted()
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::shouldTreatURLAsSameAsCurrent(const KURL&) const
	{
	notImplemented();
	return false;
	}

	void FrameLoaderClientHaiku::addHistoryItemForFragmentScroll()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::didFinishLoad()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::prepareForDataSourceReplacement()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::setTitle(const String& title, const KURL&)
	{
	notImplemented();
	}

	String FrameLoaderClientHaiku::userAgent(const KURL&)
	{
	return String("Mozilla/5.0 (compatible; U; InfiNet 0.1; Haiku) AppleWebKit/420+ (KHTML, like Gecko)");
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveIcon()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::frameLoaderDestroyed()
	{
	m_frame = 0;
	m_messenger = 0;
	delete this;
	}

	bool FrameLoaderClientHaiku::canHandleRequest(const WebCore::ResourceRequest&) const
	{
	notImplemented();
	return true;
	}

	void FrameLoaderClientHaiku::partClearedInBegin()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateGlobalHistory()
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::updateGlobalHistoryRedirectLinks()
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::shouldGoToHistoryItem(WebCore::HistoryItem*) const
	{
	notImplemented();
	return true;
	}

	bool FrameLoaderClientHaiku::shouldStopLoadingForHistoryItem(WebCore::HistoryItem*) const
	{
	return true;
	}

	void FrameLoaderClientHaiku::dispatchDidAddBackForwardItem(WebCore::HistoryItem*) const
	{
	}

	void FrameLoaderClientHaiku::dispatchDidRemoveBackForwardItem(WebCore::HistoryItem*) const
	{
	}

	void FrameLoaderClientHaiku::dispatchDidChangeBackForwardIndex() const
	{
	}

	void FrameLoaderClientHaiku::saveScrollPositionAndViewStateToItem(WebCore::HistoryItem*)
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::canCachePage() const
	{
	return false;
	}

	void FrameLoaderClientHaiku::setMainDocumentError(WebCore::DocumentLoader*, const WebCore::ResourceError&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
	{
	loader->commitData(data, length);
	}

	WebCore::ResourceError FrameLoaderClientHaiku::cancelledError(const WebCore::ResourceRequest& request)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
	}

	WebCore::ResourceError FrameLoaderClientHaiku::blockedError(const ResourceRequest& request)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
	}

	WebCore::ResourceError FrameLoaderClientHaiku::cannotShowURLError(const WebCore::ResourceRequest& request)
	{
	return ResourceError(String(), WebKitErrorCannotShowURL, request.url().string(), String());
	}

	WebCore::ResourceError FrameLoaderClientHaiku::interruptForPolicyChangeError(const WebCore::ResourceRequest& request)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(), String());
	}

	WebCore::ResourceError FrameLoaderClientHaiku::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url().string(), String());
	}

	WebCore::ResourceError FrameLoaderClientHaiku::fileDoesNotExistError(const WebCore::ResourceResponse& response)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorCannotShowURL, response.url().string(), String());
	}

	bool FrameLoaderClientHaiku::shouldFallBack(const WebCore::ResourceError& error)
	{
	notImplemented();
	return false;
	}

	WTF::PassRefPtr<DocumentLoader> FrameLoaderClientHaiku::createDocumentLoader(const ResourceRequest& request,
	const SubstituteData& substituteData)
	{
	return DocumentLoader::create(request, substituteData);
	}

	void FrameLoaderClientHaiku::download(ResourceHandle*, const ResourceRequest&,
	const ResourceRequest&, const ResourceResponse&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*,
	const ResourceRequest&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest& request,
	const ResourceResponse& response)
	{
	notImplemented();
	}

	bool FrameLoaderClientHaiku::shouldUseCredentialStorage(DocumentLoader*, unsigned long)
	{
	notImplemented();
	return false;
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveAuthenticationChallenge(DocumentLoader*,
	unsigned long, const AuthenticationChallenge&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidCancelAuthenticationChallenge(DocumentLoader*,
	unsigned long, const AuthenticationChallenge&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveResponse(DocumentLoader* loader, unsigned long id,
	const ResourceResponse& response)
	{
	notImplemented();
	m_response = response;
	m_firstData = true;
	}

	void FrameLoaderClientHaiku::dispatchDidReceiveContentLength(DocumentLoader* loader,
	unsigned long id, int length)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidFinishLoading(DocumentLoader*, unsigned long)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidFailLoading(DocumentLoader* loader,
	unsigned long, const ResourceError&)
	{
	if (m_webView) {
	BMessage message(LOAD_FAILED);
	message.AddString("url", m_frame->loader()->documentLoader()->request().url().string());
	m_messenger->SendMessage(&message);
	}
	}

	bool FrameLoaderClientHaiku::dispatchDidLoadResourceFromMemoryCache(DocumentLoader*,
	const ResourceRequest&,
	const ResourceResponse&, int)
	{
	notImplemented();
	return false;
	}

	void FrameLoaderClientHaiku::dispatchDidFailProvisionalLoad(const ResourceError&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::dispatchDidFailLoad(const ResourceError&)
	{
	notImplemented();
	}

	Frame* FrameLoaderClientHaiku::dispatchCreatePage(const WebCore::NavigationAction&)
	{
	notImplemented();
	return false;
	}

	void FrameLoaderClientHaiku::dispatchDecidePolicyForResponse(FramePolicyFunction function,
	const ResourceResponse& response,
	const ResourceRequest& request)
	{
	if (!m_frame)
	return;

	notImplemented();
	(m_frame->loader()->policyChecker()->*function)(PolicyUse);
	}

	void FrameLoaderClientHaiku::dispatchDecidePolicyForNewWindowAction(FramePolicyFunction function,
	const NavigationAction&,
	const ResourceRequest& request,
	PassRefPtr<FormState>, const String& targetName)
	{
	if (!m_frame)
	return;

	if (m_webView) {
	BMessage message(NEW_WINDOW_REQUESTED);
	message.AddString("url", request.url().string());
	if (m_messenger->SendMessage(&message)) {
	(m_frame->loader()->policyChecker()->*function)(PolicyIgnore);
	return;
	}
	}

	(m_frame->loader()->policyChecker()->*function)(PolicyUse);
	}

	void FrameLoaderClientHaiku::dispatchDecidePolicyForNavigationAction(FramePolicyFunction function,
	const NavigationAction& action,
	const ResourceRequest& request,
	PassRefPtr<FormState>)
	{
	if (!m_frame \|\| !function)
	return;

	if (m_webView) {
	BMessage message(NAVIGATION_REQUESTED);
	message.AddString("url", request.url().string());
	m_messenger->SendMessage(&message);

	(m_frame->loader()->policyChecker()->*function)(PolicyUse);
	}
	}

	void FrameLoaderClientHaiku::dispatchUnableToImplementPolicy(const ResourceError&)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::startDownload(const ResourceRequest&)
	{
	notImplemented();
	}

	PassRefPtr<Frame> FrameLoaderClientHaiku::createFrame(const KURL& url, const String& name,
	HTMLFrameOwnerElement* ownerElement,
	const String& referrer, bool allowsScrolling,
	int marginWidth, int marginHeight)
	{
	// FIXME: We should apply the right property to the frameView. (scrollbar,margins)

	RefPtr<Frame> childFrame = Frame::create(m_frame->page(), ownerElement, this);
	setFrame(childFrame.get());

	RefPtr<FrameView> frameView = FrameView::create(childFrame.get());

	frameView->setAllowsScrolling(allowsScrolling);
	frameView->deref();
	childFrame->setView(frameView.get());
	childFrame->init();

	childFrame->tree()->setName(name);
	m_frame->tree()->appendChild(childFrame);

	m_frame->loader()->loadURLIntoChildFrame(url, referrer, childFrame.get());

	// The frame's onload handler may have removed it from the document.
	if (!childFrame->tree()->parent())
	return 0;

	return childFrame.release();

	notImplemented();
	return 0;
	}

	void FrameLoaderClientHaiku::didTransferChildFrameToNewDocument(Page*)
	{
	}

	void FrameLoaderClientHaiku::transferLoadingResourceFromPage(unsigned long, DocumentLoader, const ResourceRequest&, Page)
	{
	}

	ObjectContentType FrameLoaderClientHaiku::objectContentType(const KURL& url, const String& mimeType, bool shouldPreferPlugInsForImages)
	{
	notImplemented();
	return ObjectContentType();
	}

	PassRefPtr<Widget> FrameLoaderClientHaiku::createPlugin(const IntSize&, HTMLPlugInElement*,
	const KURL&, const Vector<String>&,
	const Vector<String>&, const String&,
	bool loadManually)
	{
	notImplemented();
	return 0;
	}

	void FrameLoaderClientHaiku::redirectDataToPlugin(Widget* pluginWidget)
	{
	notImplemented();
	return;
	}

	ResourceError FrameLoaderClientHaiku::pluginWillHandleLoadError(const ResourceResponse& response)
	{
	notImplemented();
	return ResourceError(String(), WebKitErrorCannotLoadPlugIn, response.url().string(), String());
	}

	PassRefPtr<Widget> FrameLoaderClientHaiku::createJavaAppletWidget(const IntSize&, HTMLAppletElement*,
	const KURL& baseURL,
	const Vector<String>& paramNames,
	const Vector<String>& paramValues)
	{
	notImplemented();
	return 0;
	}

	String FrameLoaderClientHaiku::overrideMediaType() const
	{
	notImplemented();
	return String();
	}

	void FrameLoaderClientHaiku::dispatchDidClearWindowObjectInWorld(DOMWrapperWorld* world)
	{
	if (world != mainThreadNormalWorld())
	return;

	if (m_webView) {
	BMessage message(JAVASCRIPT_WINDOW_OBJECT_CLEARED);
	m_messenger->SendMessage(&message);
	}
	}

	void FrameLoaderClientHaiku::documentElementAvailable()
	{
	}

	void FrameLoaderClientHaiku::didPerformFirstNavigation() const
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::registerForIconNotification(bool listen)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::savePlatformDataToCachedFrame(CachedFrame*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::transitionToCommittedFromCachedFrame(CachedFrame*)
	{
	notImplemented();
	}

	void FrameLoaderClientHaiku::transitionToCommittedForNewPage()
	{
	ASSERT(m_frame);
	ASSERT(m_webView);

	Page* page = m_frame->page();
	ASSERT(page);

	bool isMainFrame = m_frame == page->mainFrame();

	m_frame->setView(0);

	RefPtr<FrameView> frameView;
	if (isMainFrame) {
	if (m_webView->LockLooper()) {
	// We lock the looper in order to get the bounds of the WebView.
	frameView = FrameView::create(m_frame, IntRect(m_webView->Bounds()).size());
	m_webView->UnlockLooper();
	}
	} else
	frameView = FrameView::create(m_frame);

	ASSERT(frameView);
	m_frame->setView(frameView);

	frameView->setPlatformWidget(m_webView);

	if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
	m_frame->view()->setScrollbarModes(owner->scrollingMode(), owner->scrollingMode());
	}

	void FrameLoaderClientHaiku::didSaveToPageCache()
	{
	}

	void FrameLoaderClientHaiku::didRestoreFromPageCache()
	{
	}

	void FrameLoaderClientHaiku::dispatchDidBecomeFrameset(bool)
	{
	}

	} // namespace WebCore