/*

* Copyright (C) 2006-2009, 2011, 2013-2015 Apple Inc. All rights reserved.

* Copyright (C) Research In Motion Limited 2009. 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 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 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 "WebKitDLL.h"

#include "WebFrame.h"

#include "CFDictionaryPropertyBag.h"

#include "COMPropertyBag.h"

#include "DOMCoreClasses.h"

#include "MarshallingHelpers.h"

#include "WebActionPropertyBag.h"

#include "WebChromeClient.h"

#include "WebDataSource.h"

#include "WebDocumentLoader.h"

#include "WebDownload.h"

#include "WebEditorClient.h"

#include "WebError.h"

#include "WebFrameLoaderClient.h"

#include "WebFramePolicyListener.h"

#include "WebHistory.h"

#include "WebHistoryItem.h"

#include "WebKit.h"

#include "WebKitStatisticsPrivate.h"

#include "WebMutableURLRequest.h"

#include "WebNotificationCenter.h"

#include "WebScriptWorld.h"

#include "WebURLResponse.h"

#include "WebView.h"

#include <JavaScriptCore/APICast.h>

#include <JavaScriptCore/HeapInlines.h>

#include <JavaScriptCore/JSCJSValue.h>

#include <JavaScriptCore/JSLock.h>

#include <JavaScriptCore/JSObject.h>

#include <WebCore/BString.h>

#include <WebCore/COMPtr.h>

#include <WebCore/DOMWindow.h>

#include <WebCore/Document.h>

#include <WebCore/DocumentLoader.h>

#include <WebCore/DocumentMarkerController.h>

#include <WebCore/Editor.h>

#include <WebCore/Event.h>

#include <WebCore/EventHandler.h>

#include <WebCore/FormState.h>

#include <WebCore/Frame.h>

#include <WebCore/FrameLoadRequest.h>

#include <WebCore/FrameLoader.h>

#include <WebCore/FrameTree.h>

#include <WebCore/FrameView.h>

#include <WebCore/FrameWin.h>

#include <WebCore/GDIObjectCounter.h>

#include <WebCore/GraphicsContext.h>

#include <WebCore/GraphicsContextWin.h>

#include <WebCore/HTMLFormControlElement.h>

#include <WebCore/HTMLFormElement.h>

#include <WebCore/HTMLFrameOwnerElement.h>

#include <WebCore/HTMLInputElement.h>

#include <WebCore/HTMLNames.h>

#include <WebCore/HTMLPlugInElement.h>

#include <WebCore/HistoryItem.h>

#include <WebCore/JSDOMBinding.h>

#include <WebCore/JSDOMWindow.h>

#include <WebCore/KeyboardEvent.h>

#include <WebCore/MIMETypeRegistry.h>

#include <WebCore/MemoryCache.h>

#include <WebCore/MouseRelatedEvent.h>

#include <WebCore/NotImplemented.h>

#include <WebCore/Page.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/PluginData.h>

#include <WebCore/PolicyChecker.h>

#include <WebCore/PrintContext.h>

#include <WebCore/RenderLayerCompositor.h>

#include <WebCore/RenderTreeAsText.h>

#include <WebCore/RenderView.h>

#include <WebCore/ResourceHandle.h>

#include <WebCore/ResourceLoader.h>

#include <WebCore/ResourceRequest.h>

#include <WebCore/ScriptController.h>

#include <WebCore/SecurityOrigin.h>

#include <WebCore/Settings.h>

#include <WebCore/TextIterator.h>

#include <wtf/MathExtras.h>

#if USE(CG)

#include <CoreGraphics/CoreGraphics.h>

#elif USE(CAIRO)

#include <WebCore/GraphicsContextCairo.h>

#include <cairo-win32.h>

#endif

#if USE(CG)

// CG SPI used for printing

extern "C" {

CGAffineTransform CGContextGetBaseCTM(CGContextRef c);

void CGContextSetBaseCTM(CGContextRef c, CGAffineTransform m);

}

#endif

using namespace WebCore;

using namespace HTMLNames;

using JSC::JSGlobalObject;

using JSC::JSLock;

using JSC::JSValue;

#define FLASH_REDRAW 0

// By imaging to a width a little wider than the available pixels,

// thin pages will be scaled down a little, matching the way they

// print in IE and Camino. This lets them use fewer sheets than they

// would otherwise, which is presumably why other browsers do this.

// Wide pages will be scaled down more than this.

const float PrintingMinimumShrinkFactor = 1.25f;

// This number determines how small we are willing to reduce the page content

// in order to accommodate the widest line. If the page would have to be

// reduced smaller to make the widest line fit, we just clip instead (this

// behavior matches MacIE and Mozilla, at least)

const float PrintingMaximumShrinkFactor = 2.0f;

//-----------------------------------------------------------------------------

// Helpers to convert from WebCore to WebKit type

WebFrame* kit(Frame* frame)

{

if (!frame)

return nullptr;

// FIXME: Doesn't this need to be aware of EmptyFrameLoaderClient?

FrameLoaderClient& frameLoaderClient = frame->loader().client();

return static_cast<WebFrameLoaderClient&>(frameLoaderClient).webFrame();

}

Frame* core(WebFrame* webFrame)

{

if (!webFrame)

return nullptr;

return webFrame->impl();

}

// This function is not in WebFrame.h because we don't want to advertise the ability to get a non-const Frame from a const WebFrame

Frame* core(const WebFrame* webFrame)

{

if (!webFrame)

return nullptr;

return const_cast<WebFrame*>(webFrame)->impl();

}

//-----------------------------------------------------------------------------

static Element* elementFromDOMElement(IDOMElement* element)

{

if (!element)

return nullptr;

COMPtr<IDOMElementPrivate> elePriv;

HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

if (SUCCEEDED(hr)) {

Element* ele;

hr = elePriv->coreElement((void**)&ele);

if (SUCCEEDED(hr))

return ele;

}

return 0;

}

static HTMLFormElement *formElementFromDOMElement(IDOMElement *element)

{

if (!element)

return nullptr;

IDOMElementPrivate* elePriv;

HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

if (SUCCEEDED(hr)) {

Element* ele;

hr = elePriv->coreElement((void**)&ele);

elePriv->Release();

if (SUCCEEDED(hr) && is<HTMLFormElement>(ele))

return downcast<HTMLFormElement>(ele);

}

return nullptr;

}

static HTMLInputElement* inputElementFromDOMElement(IDOMElement* element)

{

if (!element)

return nullptr;

IDOMElementPrivate* elePriv;

HRESULT hr = element->QueryInterface(IID_IDOMElementPrivate, (void**) &elePriv);

if (SUCCEEDED(hr)) {

Element* ele;

hr = elePriv->coreElement((void**)&ele);

elePriv->Release();

if (SUCCEEDED(hr) && is<HTMLInputElement>(ele))

return downcast<HTMLInputElement>(ele);

}

return nullptr;

}

// WebFramePrivate ------------------------------------------------------------

class WebFrame::WebFramePrivate {

public:

WebFramePrivate()

{

}

~WebFramePrivate() { }

FrameView* frameView() { return frame ? frame->view() : nullptr; }

Frame* frame { nullptr };

WebView* webView { nullptr };

};

// WebFrame ----------------------------------------------------------------

WebFrame::WebFrame()

: d(new WebFrame::WebFramePrivate)

{

WebFrameCount++;

gClassCount++;

gClassNameCount().add("WebFrame");

}

WebFrame::~WebFrame()

{

delete d;

WebFrameCount--;

gClassCount--;

gClassNameCount().remove("WebFrame");

}

WebFrame* WebFrame::createInstance()

{

WebFrame* instance = new WebFrame();

instance->AddRef();

return instance;

}

HRESULT WebFrame::setAllowsScrolling(BOOL flag)

{

if (Frame* frame = core(this))

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

view->setCanHaveScrollbars(!!flag);

return S_OK;

}

HRESULT WebFrame::allowsScrolling(_Out_ BOOL* flag)

{

if (!flag)

return E_POINTER;

*flag = FALSE;

if (Frame* frame = core(this)) {

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

*flag = view->canHaveScrollbars();

}

return S_OK;

}

HRESULT WebFrame::setIsDisconnected(BOOL flag)

{

ASSERT_NOT_REACHED();

return E_FAIL;

}

HRESULT WebFrame::setExcludeFromTextSearch(BOOL flag)

{

ASSERT_NOT_REACHED();

return E_NOTIMPL;

}

HRESULT WebFrame::reloadFromOrigin()

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

coreFrame->loader().reload(WebCore::ReloadOption::FromOrigin);

return S_OK;

}

HRESULT WebFrame::paintDocumentRectToContext(RECT rect, _In_ HDC deviceContext)

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

FrameView* view = coreFrame->view();

if (!view)

return E_FAIL;

// We can't paint with a layout still pending.

view->updateLayoutAndStyleIfNeededRecursive();

GraphicsContextWin gc(deviceContext);

gc.save();

LONG width = rect.right - rect.left;

LONG height = rect.bottom - rect.top;

FloatRect dirtyRect;

dirtyRect.setWidth(width);

dirtyRect.setHeight(height);

gc.clip(dirtyRect);

gc.translate(-rect.left, -rect.top);

float scaleFactor = webView()->deviceScaleFactor();

gc.scale(WebCore::FloatSize(scaleFactor, scaleFactor));

view->paintContents(gc, rect);

gc.restore();

return S_OK;

}

HRESULT WebFrame::paintScrollViewRectToContextAtPoint(RECT rect, POINT pt, _In_ HDC deviceContext)

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

FrameView* view = coreFrame->view();

if (!view)

return E_FAIL;

// We can't paint with a layout still pending.

view->updateLayoutAndStyleIfNeededRecursive();

GraphicsContextWin gc(deviceContext);

gc.save();

IntRect dirtyRect(rect);

dirtyRect.move(-pt.x, -pt.y);

float scaleFactor = webView()->deviceScaleFactor();

gc.scale(WebCore::FloatSize(scaleFactor, scaleFactor));

view->paint(gc, dirtyRect);

gc.restore();

return S_OK;

}

// IUnknown -------------------------------------------------------------------

HRESULT WebFrame::QueryInterface(_In_ REFIID riid, _COM_Outptr_ void** ppvObject)

{

if (!ppvObject)

return E_POINTER;

*ppvObject = nullptr;

if (IsEqualGUID(riid, __uuidof(WebFrame)))

*ppvObject = this;

else if (IsEqualGUID(riid, IID_IUnknown))

*ppvObject = static_cast<IWebFrame2*>(this);

else if (IsEqualGUID(riid, IID_IWebFrame))

*ppvObject = static_cast<IWebFrame2*>(this);

else if (IsEqualGUID(riid, IID_IWebFrame2))

*ppvObject = static_cast<IWebFrame2*>(this);

else if (IsEqualGUID(riid, IID_IWebFramePrivate))

*ppvObject = static_cast<IWebFramePrivate*>(this);

else if (IsEqualGUID(riid, IID_IWebDocumentText))

*ppvObject = static_cast<IWebDocumentText*>(this);

else

return E_NOINTERFACE;

AddRef();

return S_OK;

}

ULONG WebFrame::AddRef()

{

return ++m_refCount;

}

ULONG WebFrame::Release()

{

ULONG newRef = --m_refCount;

if (!newRef)

delete(this);

return newRef;

}

// IWebFrame -------------------------------------------------------------------

HRESULT WebFrame::name(_Deref_opt_out_ BSTR* frameName)

{

if (!frameName) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*frameName = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*frameName = BString(coreFrame->tree().uniqueName()).release();

return S_OK;

}

HRESULT WebFrame::webView(_COM_Outptr_opt_ IWebView** view)

{

if (!view)

return E_POINTER;

*view = nullptr;

if (!d->webView)

return E_FAIL;

*view = d->webView;

(*view)->AddRef();

return S_OK;

}

HRESULT WebFrame::frameView(_COM_Outptr_opt_ IWebFrameView** view)

{

ASSERT_NOT_REACHED();

if (!view)

return E_POINTER;

*view = nullptr;

return E_NOTIMPL;

}

HRESULT WebFrame::DOMDocument(_COM_Outptr_opt_ IDOMDocument** result)

{

if (!result) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*result = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

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

*result = DOMDocument::createInstance(document);

return *result ? S_OK : E_FAIL;

}

HRESULT WebFrame::DOMWindow(_COM_Outptr_opt_ IDOMWindow** window)

{

if (!window) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*window = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

if (WebCore::DOMWindow* coreWindow = coreFrame->document()->domWindow())

*window = ::DOMWindow::createInstance(coreWindow);

return *window ? S_OK : E_FAIL;

}

HRESULT WebFrame::frameElement(_COM_Outptr_opt_ IDOMHTMLElement** frameElement)

{

if (!frameElement)

return E_POINTER;

*frameElement = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

COMPtr<IDOMElement> domElement(AdoptCOM, DOMElement::createInstance(coreFrame->ownerElement()));

COMPtr<IDOMHTMLElement> htmlElement(Query, domElement);

if (!htmlElement)

return E_FAIL;

return htmlElement.copyRefTo(frameElement);

}

HRESULT WebFrame::currentForm(_COM_Outptr_opt_ IDOMElement** currentForm)

{

if (!currentForm) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*currentForm = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

if (HTMLFormElement* formElement = coreFrame->selection().currentForm())

*currentForm = DOMElement::createInstance(formElement);

return *currentForm ? S_OK : E_FAIL;

}

JSGlobalContextRef WebFrame::globalContext()

{

Frame* coreFrame = core(this);

if (!coreFrame)

return nullptr;

return toGlobalRef(coreFrame->script().globalObject(mainThreadNormalWorld()));

}

JSGlobalContextRef WebFrame::globalContextForScriptWorld(IWebScriptWorld* iWorld)

{

Frame* coreFrame = core(this);

if (!coreFrame)

return 0;

COMPtr<WebScriptWorld> world(Query, iWorld);

if (!world)

return 0;

return toGlobalRef(coreFrame->script().globalObject(world->world()));

}

HRESULT WebFrame::loadRequest(_In_opt_ IWebURLRequest* request)

{

if (!request)

return S_OK;

COMPtr<WebMutableURLRequest> requestImpl;

HRESULT hr = request->QueryInterface(&requestImpl);

if (FAILED(hr))

return hr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

coreFrame->loader().load(FrameLoadRequest(*coreFrame, requestImpl->resourceRequest()));

return S_OK;

}

void WebFrame::loadData(Ref<WebCore::SharedBuffer>&& data, BSTR mimeType, BSTR textEncodingName, BSTR baseURL, BSTR failingURL)

{

String mimeTypeString(mimeType, SysStringLen(mimeType));

if (!mimeType)

mimeTypeString = "text/html";

String encodingString(textEncodingName, SysStringLen(textEncodingName));

// FIXME: We should really be using MarshallingHelpers::BSTRToKURL here,

// but that would turn a null BSTR into a null URL, and we crash inside of

// WebCore if we use a null URL in constructing the ResourceRequest.

URL baseCoreURL = URL(URL(), String(baseURL ? baseURL : L"", SysStringLen(baseURL)));

URL failingCoreURL = MarshallingHelpers::BSTRToKURL(failingURL);

ResourceRequest request(baseCoreURL);

ResourceResponse response(URL(), mimeTypeString, data->size(), encodingString);

SubstituteData substituteData(WTFMove(data), failingCoreURL, response, SubstituteData::SessionHistoryVisibility::Hidden);

// This method is only called from IWebFrame methods, so don't ASSERT that the Frame pointer isn't null.

if (Frame* coreFrame = core(this))

coreFrame->loader().load(FrameLoadRequest(*coreFrame, request, substituteData));

}

HRESULT WebFrame::loadData(_In_opt_ IStream* data, _In_ BSTR mimeType, _In_ BSTR textEncodingName, _In_ BSTR url)

{

auto sharedBuffer = SharedBuffer::create();

STATSTG stat;

if (SUCCEEDED(data->Stat(&stat, STATFLAG_NONAME))) {

if (!stat.cbSize.HighPart && stat.cbSize.LowPart) {

Vector<char> dataBuffer(stat.cbSize.LowPart);

ULONG read;

// FIXME: this does a needless copy, would be better to read right into the SharedBuffer

// or adopt the Vector or something.

if (SUCCEEDED(data->Read(dataBuffer.data(), static_cast<ULONG>(dataBuffer.size()), &read)))

sharedBuffer->append(dataBuffer.data(), static_cast<int>(dataBuffer.size()));

}

}

loadData(WTFMove(sharedBuffer), mimeType, textEncodingName, url, nullptr);

return S_OK;

}

HRESULT WebFrame::loadPlainTextString(_In_ BSTR plainText, _In_ BSTR url)

{

auto sharedBuffer = SharedBuffer::create(reinterpret_cast<char*>(plainText), sizeof(UChar) * SysStringLen(plainText));

BString plainTextMimeType(TEXT("text/plain"), 10);

BString utf16Encoding(TEXT("utf-16"), 6);

loadData(WTFMove(sharedBuffer), plainTextMimeType, utf16Encoding, url, nullptr);

return S_OK;

}

void WebFrame::loadHTMLString(_In_ BSTR htmlString, _In_ BSTR baseURL, _In_ BSTR unreachableURL)

{

auto sharedBuffer = SharedBuffer::create(reinterpret_cast<char*>(htmlString), sizeof(UChar) * SysStringLen(htmlString));

BString utf16Encoding(TEXT("utf-16"), 6);

loadData(WTFMove(sharedBuffer), 0, utf16Encoding, baseURL, unreachableURL);

}

HRESULT WebFrame::loadHTMLString(_In_ BSTR htmlString, _In_ BSTR baseURL)

{

loadHTMLString(htmlString, baseURL, nullptr);

return S_OK;

}

HRESULT WebFrame::loadAlternateHTMLString(_In_ BSTR str, _In_ BSTR baseURL, _In_ BSTR unreachableURL)

{

loadHTMLString(str, baseURL, unreachableURL);

return S_OK;

}

HRESULT WebFrame::loadArchive(_In_opt_ IWebArchive* /*archive*/)

{

ASSERT_NOT_REACHED();

return E_NOTIMPL;

}

static inline WebDataSource* getWebDataSource(DocumentLoader* loader)

{

return loader ? static_cast<WebDocumentLoader*>(loader)->dataSource() : nullptr;

}

HRESULT WebFrame::dataSource(_COM_Outptr_opt_ IWebDataSource** source)

{

if (!source) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*source = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

WebDataSource* webDataSource = getWebDataSource(coreFrame->loader().documentLoader());

*source = webDataSource;

if (webDataSource)

webDataSource->AddRef();

return *source ? S_OK : E_FAIL;

}

HRESULT WebFrame::provisionalDataSource(_COM_Outptr_opt_ IWebDataSource** source)

{

if (!source) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*source = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

WebDataSource* webDataSource = getWebDataSource(coreFrame->loader().provisionalDocumentLoader());

*source = webDataSource;

if (webDataSource)

webDataSource->AddRef();

return *source ? S_OK : E_FAIL;

}

URL WebFrame::url() const

{

Frame* coreFrame = core(this);

if (!coreFrame)

return URL();

return coreFrame->document()->url();

}

HRESULT WebFrame::stopLoading()

{

if (Frame* coreFrame = core(this))

coreFrame->loader().stopAllLoaders();

return S_OK;

}

HRESULT WebFrame::reload()

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

coreFrame->loader().reload();

return S_OK;

}

HRESULT WebFrame::findFrameNamed(_In_ BSTR name, _COM_Outptr_opt_ IWebFrame** frame)

{

if (!frame) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*frame = nullptr;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

Frame* foundFrame = coreFrame->tree().find(AtomString(name, SysStringLen(name)), *coreFrame);

if (!foundFrame)

return S_OK;

WebFrame* foundWebFrame = kit(foundFrame);

if (!foundWebFrame)

return E_FAIL;

return foundWebFrame->QueryInterface(IID_IWebFrame, (void**)frame);

}

HRESULT WebFrame::parentFrame(_COM_Outptr_opt_ IWebFrame** frame)

{

if (!frame)

return E_POINTER;

*frame = nullptr;

HRESULT hr = S_OK;

if (Frame* coreFrame = core(this))

if (WebFrame* webFrame = kit(coreFrame->tree().parent()))

hr = webFrame->QueryInterface(IID_IWebFrame, (void**) frame);

return hr;

}

class EnumChildFrames final : public IEnumVARIANT

{

public:

EnumChildFrames(Frame* f)

: m_frame(f), m_curChild(f ? f->tree().firstChild() : nullptr)

{

}

virtual HRESULT STDMETHODCALLTYPE QueryInterface(_In_ REFIID riid, _COM_Outptr_ void** ppvObject)

{

*ppvObject = nullptr;

if (IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IEnumVARIANT))

*ppvObject = this;

else

return E_NOINTERFACE;

AddRef();

return S_OK;

}

virtual ULONG STDMETHODCALLTYPE AddRef()

{

return ++m_refCount;

}

virtual ULONG STDMETHODCALLTYPE Release()

{

ULONG newRef = --m_refCount;

if (!newRef)

delete(this);

return newRef;

}

virtual HRESULT STDMETHODCALLTYPE Next(ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)

{

if (pCeltFetched)

*pCeltFetched = 0;

if (!rgVar)

return E_POINTER;

::VariantInit(rgVar);

if (!celt || celt > 1)

return S_FALSE;

if (!m_frame || !m_curChild)

return S_FALSE;

WebFrame* webFrame = kit(m_curChild);

IUnknown* unknown;

HRESULT hr = webFrame->QueryInterface(IID_IUnknown, (void**)&unknown);

if (FAILED(hr))

return hr;

V_VT(rgVar) = VT_UNKNOWN;

V_UNKNOWN(rgVar) = unknown;

m_curChild = m_curChild->tree().nextSibling();

if (pCeltFetched)

*pCeltFetched = 1;

return S_OK;

}

virtual HRESULT STDMETHODCALLTYPE Skip(ULONG celt)

{

if (!m_frame)

return S_FALSE;

for (unsigned i = 0; i < celt && m_curChild; i++)

m_curChild = m_curChild->tree().nextSibling();

return m_curChild ? S_OK : S_FALSE;

}

virtual HRESULT STDMETHODCALLTYPE Reset(void)

{

if (!m_frame)

return S_FALSE;

m_curChild = m_frame->tree().firstChild();

return S_OK;

}

virtual HRESULT STDMETHODCALLTYPE Clone(IEnumVARIANT**)

{

return E_NOTIMPL;

}

private:

ULONG m_refCount { 1 };

Frame* m_frame;

Frame* m_curChild;

};

HRESULT WebFrame::childFrames(_COM_Outptr_opt_ IEnumVARIANT** enumFrames)

{

if (!enumFrames)

return E_POINTER;

*enumFrames = new EnumChildFrames(core(this));

return S_OK;

}

// IWebFramePrivate ------------------------------------------------------

enum WebRenderTreeAsTextOption {

WebRenderTreeAsTextShowAllLayers = 1 << 0,

WebRenderTreeAsTextShowLayerNesting = 1 << 1,

WebRenderTreeAsTextShowCompositedLayers = 1 << 2,

WebRenderTreeAsTextShowOverflow = 1 << 3,

WebRenderTreeAsTextShowSVGGeometry = 1 << 4,

WebRenderTreeAsTextShowLayerFragments = 1 << 5

};

typedef unsigned WebRenderTreeAsTextOptions;

static OptionSet<RenderAsTextFlag> toRenderAsTextFlags(WebRenderTreeAsTextOptions options)

{

OptionSet<RenderAsTextFlag> flags;

if (options & WebRenderTreeAsTextShowAllLayers)

flags.add(RenderAsTextFlag::ShowAllLayers);

if (options & WebRenderTreeAsTextShowLayerNesting)

flags.add(RenderAsTextFlag::ShowLayerNesting);

if (options & WebRenderTreeAsTextShowCompositedLayers)

flags.add(RenderAsTextFlag::ShowCompositedLayers);

if (options & WebRenderTreeAsTextShowOverflow)

flags.add(RenderAsTextFlag::ShowOverflow);

if (options & WebRenderTreeAsTextShowSVGGeometry)

flags.add(RenderAsTextFlag::ShowSVGGeometry);

if (options & WebRenderTreeAsTextShowLayerFragments)

flags.add(RenderAsTextFlag::ShowLayerFragments);

return flags;

}

HRESULT WebFrame::renderTreeAsExternalRepresentation(unsigned options, _Deref_opt_out_ BSTR* result)

{

if (!result)

return E_POINTER;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*result = BString(externalRepresentation(coreFrame, toRenderAsTextFlags(options))).release();

return S_OK;

}

HRESULT WebFrame::renderTreeAsExternalRepresentationForPrinting(_Deref_opt_out_ BSTR* result)

{

if (!result)

return E_POINTER;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*result = BString(externalRepresentation(coreFrame, { RenderAsTextFlag::PrintingMode })).release();

return S_OK;

}

HRESULT WebFrame::pageNumberForElementById(_In_ BSTR id, float pageWidthInPixels, float pageHeightInPixels, _Out_ int* pageNumber)

{

// TODO: Please remove this function if not needed as this is LTC specific function

// and has been moved to Internals.

ASSERT_NOT_REACHED();

return E_NOTIMPL;

}

HRESULT WebFrame::numberOfPages(float pageWidthInPixels, float pageHeightInPixels, _Out_ int* pageCount)

{

// TODO: Please remove this function if not needed as this is LTC specific function

// and has been moved to Internals.

ASSERT_NOT_REACHED();

return E_NOTIMPL;

}

HRESULT WebFrame::scrollOffset(_Out_ SIZE* offset)

{

if (!offset) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

FrameView* view = coreFrame->view();

if (!view)

return E_FAIL;

*offset = toIntSize(view->scrollPosition());

return S_OK;

}

HRESULT WebFrame::layout()

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

FrameView* view = coreFrame->view();

if (!view)

return E_FAIL;

view->layoutContext().layout();

return S_OK;

}

HRESULT WebFrame::firstLayoutDone(_Out_ BOOL* result)

{

if (!result) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*result = FALSE;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*result = coreFrame->loader().stateMachine().firstLayoutDone();

return S_OK;

}

HRESULT WebFrame::pendingFrameUnloadEventCount(_Out_ UINT* result)

{

if (!result) {

ASSERT_NOT_REACHED();

return E_POINTER;

}

*result = 0;

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*result = coreFrame->document()->domWindow()->pendingUnloadEventListeners();

return S_OK;

}

HRESULT WebFrame::hasSpellingMarker(UINT from, UINT length, BOOL* result)

{

Frame* coreFrame = core(this);

if (!coreFrame)

return E_UNEXPECTED;

*result = coreFrame->editor().selectionStartHasMarkerFor(DocumentMarker::Spelling, from, length);