/*

 * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. 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. 

 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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.

 */

#import "WebFrameInternal.h"

#import "DOMCSSStyleDeclarationInternal.h"

#import "DOMDocumentFragmentInternal.h"

#import "DOMDocumentInternal.h"

#import "DOMElementInternal.h"

#import "DOMHTMLElementInternal.h"

#import "DOMNodeInternal.h"

#import "DOMRangeInternal.h"

#import "WebArchiveInternal.h"

#import "WebChromeClient.h"

#import "WebDataSourceInternal.h"

#import "WebDocumentLoaderMac.h"

#import "WebDynamicScrollBarsView.h"

#import "WebFrameLoaderClient.h"

#import "WebFrameViewInternal.h"

#import "WebHTMLView.h"

#import "WebHTMLViewInternal.h"

#import "WebIconFetcherInternal.h"

#import "WebKitStatisticsPrivate.h"

#import "WebKitVersionChecks.h"

#import "WebNSObjectExtras.h"

#import "WebNSURLExtras.h"

#import "WebScriptDebugger.h"

#import "WebScriptWorldInternal.h"

#import "WebViewInternal.h"

#import <JavaScriptCore/APICast.h>

#import <WebCore/AXObjectCache.h>

#import <WebCore/AccessibilityObject.h>

#import <WebCore/AnimationController.h>

#import <WebCore/CSSMutableStyleDeclaration.h>

#import <WebCore/Chrome.h>

#import <WebCore/ColorMac.h>

#import <WebCore/DOMImplementation.h>

#import <WebCore/DocLoader.h>

#import <WebCore/DocumentFragment.h>

#import <WebCore/EventHandler.h>

#import <WebCore/EventNames.h>

#import <WebCore/Frame.h>

#import <WebCore/FrameLoader.h>

#import <WebCore/FrameLoaderStateMachine.h>

#import <WebCore/FrameTree.h>

#import <WebCore/GraphicsContext.h>

#import <WebCore/HTMLFrameOwnerElement.h>

#import <WebCore/HistoryItem.h>

#import <WebCore/HitTestResult.h>

#import <WebCore/LegacyWebArchive.h>

#import <WebCore/Page.h>

#import <WebCore/PluginData.h>

#import <WebCore/PrintContext.h>

#import <WebCore/RenderLayer.h>

#import <WebCore/RenderPart.h>

#import <WebCore/RenderView.h>

#import <WebCore/ReplaceSelectionCommand.h>

#import <WebCore/RuntimeApplicationChecks.h>

#import <WebCore/ScriptValue.h>

#import <WebCore/SmartReplace.h>

#import <WebCore/SVGSMILElement.h>

#import <WebCore/TextIterator.h>

#import <WebCore/ThreadCheck.h>

#import <WebCore/TypingCommand.h>

#import <WebCore/htmlediting.h>

#import <WebCore/markup.h>

#import <WebCore/visible_units.h>

#import <WebKitSystemInterface.h>

#import <runtime/JSLock.h>

#import <runtime/JSObject.h>

#import <runtime/JSValue.h>

#import <wtf/CurrentTime.h>

using namespace std;

using namespace WebCore;

using namespace HTMLNames;

using JSC::JSGlobalObject;

using JSC::JSLock;

using JSC::JSValue;

using JSC::SilenceAssertionsOnly;

/*

Here is the current behavior matrix for four types of navigations:

Standard Nav:

 Restore form state:   YES

 Restore scroll and focus state:  YES

 Cache policy: NSURLRequestUseProtocolCachePolicy

 Add to back/forward list: YES

Back/Forward:

 Restore form state:   YES

 Restore scroll and focus state:  YES

 Cache policy: NSURLRequestReturnCacheDataElseLoad

 Add to back/forward list: NO

Reload (meaning only the reload button):

 Restore form state:   NO

 Restore scroll and focus state:  YES

 Cache policy: NSURLRequestReloadIgnoringCacheData

 Add to back/forward list: NO

Repeat load of the same URL (by any other means of navigation other than the reload button, including hitting return in the location field):

 Restore form state:   NO

 Restore scroll and focus state:  NO, reset to initial conditions

 Cache policy: NSURLRequestReloadIgnoringCacheData

 Add to back/forward list: NO

*/

NSString *WebPageCacheEntryDateKey = @"WebPageCacheEntryDateKey";

NSString *WebPageCacheDataSourceKey = @"WebPageCacheDataSourceKey";

NSString *WebPageCacheDocumentViewKey = @"WebPageCacheDocumentViewKey";

NSString *WebFrameMainDocumentError = @"WebFrameMainDocumentErrorKey";

NSString *WebFrameHasPlugins = @"WebFrameHasPluginsKey";

NSString *WebFrameHasUnloadListener = @"WebFrameHasUnloadListenerKey";

NSString *WebFrameUsesDatabases = @"WebFrameUsesDatabasesKey";

NSString *WebFrameUsesGeolocation = @"WebFrameUsesGeolocationKey";

NSString *WebFrameUsesApplicationCache = @"WebFrameUsesApplicationCacheKey";

NSString *WebFrameCanSuspendActiveDOMObjects = @"WebFrameCanSuspendActiveDOMObjectsKey";

// FIXME: Remove when this key becomes publicly defined

NSString *NSAccessibilityEnhancedUserInterfaceAttribute = @"AXEnhancedUserInterface";

@implementation WebFramePrivate

- (void)dealloc

{

    [webFrameView release];

    delete scriptDebugger;

    [super dealloc];

}

- (void)finalize

{

    delete scriptDebugger;

    [super finalize];

}

- (void)setWebFrameView:(WebFrameView *)v 

{ 

    [v retain];

    [webFrameView release];

    webFrameView = v;

}

@end

EditableLinkBehavior core(WebKitEditableLinkBehavior editableLinkBehavior)

{

    switch (editableLinkBehavior) {

        case WebKitEditableLinkDefaultBehavior:

            return EditableLinkDefaultBehavior;

        case WebKitEditableLinkAlwaysLive:

            return EditableLinkAlwaysLive;

        case WebKitEditableLinkOnlyLiveWithShiftKey:

            return EditableLinkOnlyLiveWithShiftKey;

        case WebKitEditableLinkLiveWhenNotFocused:

            return EditableLinkLiveWhenNotFocused;

        case WebKitEditableLinkNeverLive:

            return EditableLinkNeverLive;

    }

    ASSERT_NOT_REACHED();

    return EditableLinkDefaultBehavior;

}

WebCore::EditingBehaviorType core(WebKitEditingBehavior behavior)

{

    switch (behavior) {

        case WebKitEditingMacBehavior:

            return WebCore::EditingMacBehavior;

        case WebKitEditingWinBehavior:

            return WebCore::EditingWindowsBehavior;

    }

    ASSERT_NOT_REACHED();

    return WebCore::EditingMacBehavior;

}

TextDirectionSubmenuInclusionBehavior core(WebTextDirectionSubmenuInclusionBehavior behavior)

{

    switch (behavior) {

        case WebTextDirectionSubmenuNeverIncluded:

            return TextDirectionSubmenuNeverIncluded;

        case WebTextDirectionSubmenuAutomaticallyIncluded:

            return TextDirectionSubmenuAutomaticallyIncluded;

        case WebTextDirectionSubmenuAlwaysIncluded:

            return TextDirectionSubmenuAlwaysIncluded;

    }

    ASSERT_NOT_REACHED();

    return TextDirectionSubmenuNeverIncluded;

}

@implementation WebFrame (WebInternal)

Frame* core(WebFrame *frame)

{

    return frame ? frame->_private->coreFrame : 0;

}

WebFrame *kit(Frame* frame)

{

    return frame ? static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame() : nil;

}

Page* core(WebView *webView)

{

    return [webView page];

}

WebView *kit(Page* page)

{

    return page ? static_cast<WebChromeClient*>(page->chrome()->client())->webView() : nil;

}

WebView *getWebView(WebFrame *webFrame)

{

    Frame* coreFrame = core(webFrame);

    if (!coreFrame)

        return nil;

    return kit(coreFrame->page());

}

+ (PassRefPtr<Frame>)_createFrameWithPage:(Page*)page frameName:(const String&)name frameView:(WebFrameView *)frameView ownerElement:(HTMLFrameOwnerElement*)ownerElement

{

    WebView *webView = kit(page);

    WebFrame *frame = [[self alloc] _initWithWebFrameView:frameView webView:webView];

    RefPtr<Frame> coreFrame = Frame::create(page, ownerElement, new WebFrameLoaderClient(frame));

    [frame release];

    frame->_private->coreFrame = coreFrame.get();

    coreFrame->tree()->setName(name);

    if (ownerElement) {

        ASSERT(ownerElement->document()->frame());

        ownerElement->document()->frame()->tree()->appendChild(coreFrame.get());

    }

    coreFrame->init();

    [webView _setZoomMultiplier:[webView _realZoomMultiplier] isTextOnly:[webView _realZoomMultiplierIsTextOnly]];

    return coreFrame.release();

}

+ (void)_createMainFrameWithPage:(Page*)page frameName:(const String&)name frameView:(WebFrameView *)frameView

{

    [self _createFrameWithPage:page frameName:name frameView:frameView ownerElement:0];

}

+ (PassRefPtr<WebCore::Frame>)_createSubframeWithOwnerElement:(HTMLFrameOwnerElement*)ownerElement frameName:(const String&)name frameView:(WebFrameView *)frameView

{

    return [self _createFrameWithPage:ownerElement->document()->frame()->page() frameName:name frameView:frameView ownerElement:ownerElement];

}

- (BOOL)_isIncludedInWebKitStatistics

{

    return _private && _private->includedInWebKitStatistics;

}

- (void)_attachScriptDebugger

{

    ScriptController* scriptController = _private->coreFrame->script();

    // Calling ScriptController::globalObject() would create a window shell, and dispatch corresponding callbacks, which may be premature

    // if the script debugger is attached before a document is created.  These calls use the debuggerWorld(), we will need to pass a world

    // to be able to debug isolated worlds.

    if (!scriptController->existingWindowShell(debuggerWorld()))

        return;

    JSGlobalObject* globalObject = scriptController->globalObject(debuggerWorld());

    if (!globalObject)

        return;

    if (_private->scriptDebugger) {

        ASSERT(_private->scriptDebugger == globalObject->debugger());

        return;

    }

    _private->scriptDebugger = new WebScriptDebugger(globalObject);

}

- (void)_detachScriptDebugger

{

    if (!_private->scriptDebugger)

        return;

    delete _private->scriptDebugger;

    _private->scriptDebugger = 0;

}

- (id)_initWithWebFrameView:(WebFrameView *)fv webView:(WebView *)v

{

    self = [super init];

    if (!self)

        return nil;

    _private = [[WebFramePrivate alloc] init];

    // Set includedInWebKitStatistics before calling WebFrameView _setWebFrame, since

    // it calls WebFrame _isIncludedInWebKitStatistics.

    if ((_private->includedInWebKitStatistics = [[v class] shouldIncludeInWebKitStatistics]))

        ++WebFrameCount;

    if (fv) {

        [_private setWebFrameView:fv];

        [fv _setWebFrame:self];

    }

    _private->shouldCreateRenderers = YES;

    return self;

}

- (void)_clearCoreFrame

{

    _private->coreFrame = 0;

}

- (void)_updateBackgroundAndUpdatesWhileOffscreen

{

    WebView *webView = getWebView(self);

    BOOL drawsBackground = [webView drawsBackground];

    NSColor *backgroundColor = [webView backgroundColor];

    Frame* coreFrame = _private->coreFrame;

    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

        if ([webView _usesDocumentViews]) {

            // Don't call setDrawsBackground:YES here because it may be NO because of a load

            // in progress; WebFrameLoaderClient keeps it set to NO during the load process.

            WebFrame *webFrame = kit(frame);

            if (!drawsBackground)

                [[[webFrame frameView] _scrollView] setDrawsBackground:NO];

            [[[webFrame frameView] _scrollView] setBackgroundColor:backgroundColor];

            id documentView = [[webFrame frameView] documentView];

            if ([documentView respondsToSelector:@selector(setDrawsBackground:)])

                [documentView setDrawsBackground:drawsBackground];

            if ([documentView respondsToSelector:@selector(setBackgroundColor:)])

                [documentView setBackgroundColor:backgroundColor];

        }

        if (FrameView* view = frame->view()) {

            view->setTransparent(!drawsBackground);

            view->setBaseBackgroundColor(colorFromNSColor([backgroundColor colorUsingColorSpaceName:NSDeviceRGBColorSpace]));

            view->setShouldUpdateWhileOffscreen([webView shouldUpdateWhileOffscreen]);

        }

    }

}

- (void)_setInternalLoadDelegate:(id)internalLoadDelegate

{

    _private->internalLoadDelegate = internalLoadDelegate;

}

- (id)_internalLoadDelegate

{

    return _private->internalLoadDelegate;

}

#ifndef BUILDING_ON_TIGER

- (void)_unmarkAllBadGrammar

{

    Frame* coreFrame = _private->coreFrame;

    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

        if (Document* document = frame->document())

            document->removeMarkers(DocumentMarker::Grammar);

    }

}

#endif

- (void)_unmarkAllMisspellings

{

    Frame* coreFrame = _private->coreFrame;

    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

        if (Document* document = frame->document())

            document->removeMarkers(DocumentMarker::Spelling);

    }

}

- (BOOL)_hasSelection

{

    if ([getWebView(self) _usesDocumentViews]) {

        id documentView = [_private->webFrameView documentView];    

        // optimization for common case to avoid creating potentially large selection string

        if ([documentView isKindOfClass:[WebHTMLView class]])

            if (Frame* coreFrame = _private->coreFrame)

                return coreFrame->selection()->isRange();

        if ([documentView conformsToProtocol:@protocol(WebDocumentText)])

            return [[documentView selectedString] length] > 0;

        return NO;

    }

    Frame* coreFrame = _private->coreFrame;

    return coreFrame && coreFrame->selection()->isRange();

}

- (void)_clearSelection

{

    ASSERT([getWebView(self) _usesDocumentViews]);

    id documentView = [_private->webFrameView documentView];    

    if ([documentView conformsToProtocol:@protocol(WebDocumentText)])

        [documentView deselectAll];

}

#if !ASSERT_DISABLED

- (BOOL)_atMostOneFrameHasSelection

{

    // FIXME: 4186050 is one known case that makes this debug check fail.

    BOOL found = NO;

    Frame* coreFrame = _private->coreFrame;

    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame))

        if ([kit(frame) _hasSelection]) {

            if (found)

                return NO;

            found = YES;

        }

    return YES;

}

#endif

- (WebFrame *)_findFrameWithSelection

{

    Frame* coreFrame = _private->coreFrame;

    for (Frame* frame = coreFrame; frame; frame = frame->tree()->traverseNext(coreFrame)) {

        WebFrame *webFrame = kit(frame);

        if ([webFrame _hasSelection])

            return webFrame;

    }

    return nil;

}

- (void)_clearSelectionInOtherFrames

{

    // We rely on WebDocumentSelection protocol implementors to call this method when they become first 

    // responder. It would be nicer to just notice first responder changes here instead, but there's no 

    // notification sent when the first responder changes in general (Radar 2573089).

    WebFrame *frameWithSelection = [[getWebView(self) mainFrame] _findFrameWithSelection];

    if (frameWithSelection != self)

        [frameWithSelection _clearSelection];

    // While we're in the general area of selection and frames, check that there is only one now.

    ASSERT([[getWebView(self) mainFrame] _atMostOneFrameHasSelection]);

}

static inline WebDataSource *dataSource(DocumentLoader* loader)

{

    return loader ? static_cast<WebDocumentLoaderMac*>(loader)->dataSource() : nil;

}

- (WebDataSource *)_dataSource

{

    return dataSource(_private->coreFrame->loader()->documentLoader());

}

- (void)_addData:(NSData *)data

{

    Document* document = _private->coreFrame->document();

    // Document may be nil if the part is about to redirect

    // as a result of JS executing during load, i.e. one frame

    // changing another's location before the frame's document

    // has been created. 

    if (!document)

        return;

    document->setShouldCreateRenderers(_private->shouldCreateRenderers);

    _private->coreFrame->loader()->addData((const char *)[data bytes], [data length]);

}

- (NSString *)_stringWithDocumentTypeStringAndMarkupString:(NSString *)markupString

{

    return _private->coreFrame->documentTypeString() + markupString;

}

- (NSArray *)_nodesFromList:(Vector<Node*> *)nodesVector

{

    size_t size = nodesVector->size();

    NSMutableArray *nodes = [NSMutableArray arrayWithCapacity:size];

    for (size_t i = 0; i < size; ++i)

        [nodes addObject:kit((*nodesVector)[i])];

    return nodes;

}

- (NSString *)_markupStringFromRange:(DOMRange *)range nodes:(NSArray **)nodes

{

    // FIXME: This is always "for interchange". Is that right? See the previous method.

    Vector<Node*> nodeList;

    NSString *markupString = createMarkup(core(range), nodes ? &nodeList : 0, AnnotateForInterchange);

    if (nodes)

        *nodes = [self _nodesFromList:&nodeList];

    return [self _stringWithDocumentTypeStringAndMarkupString:markupString];

}