/*
* Copyright (C) 2007-2009 Google 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:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of Google Inc. 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 THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
* OWNER 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 "V8CustomBinding.h"
#include "CSSHelper.h"
#include "Element.h"
#include "Document.h"
#include "DOMWindow.h"
#include "History.h"
#include "HTMLNames.h"
#include "HTMLFrameElementBase.h"
#include "Location.h"
#include "V8Proxy.h"
#if ENABLE(SVG)
#include "SVGPathSeg.h"
#endif
namespace WebCore {
bool allowSettingFrameSrcToJavascriptUrl(HTMLFrameElementBase* frame, String value)
{
if (protocolIs(deprecatedParseURL(value), "javascript")) {
Node* contentDoc = frame->contentDocument();
if (contentDoc && !V8Proxy::checkNodeSecurity(contentDoc))
return false;
}
return true;
}
bool allowSettingSrcToJavascriptURL(Element* element, String name, String value)
{
if ((element->hasTagName(HTMLNames::iframeTag) || element->hasTagName(HTMLNames::frameTag)) && equalIgnoringCase(name, "src"))
return allowSettingFrameSrcToJavascriptUrl(static_cast<HTMLFrameElementBase*>(element), value);
return true;
}
// DOMImplementation is a singleton in WebCore. If we use our normal
// mapping from DOM objects to V8 wrappers, the same wrapper will be
// shared for all frames in the same process. This is a major
// security problem. Therefore, we generate a DOMImplementation
// wrapper per document and store it in an internal field of the
// document. Since the DOMImplementation object is a singleton, we do
// not have to do anything to keep the DOMImplementation object alive
// for the lifetime of the wrapper.
ACCESSOR_GETTER(DocumentImplementation)
{
ASSERT(info.Holder()->InternalFieldCount() >= kDocumentMinimumInternalFieldCount);
// Check if the internal field already contains a wrapper.
v8::Local<v8::Value> implementation = info.Holder()->GetInternalField(kDocumentImplementationIndex);
if (!implementation->IsUndefined())
return implementation;
// Generate a wrapper.
Document* document = V8DOMWrapper::convertDOMWrapperToNative<Document>(info.Holder());
v8::Handle<v8::Value> wrapper = V8DOMWrapper::convertDOMImplementationToV8Object(document->implementation());
// Store the wrapper in the internal field.
info.Holder()->SetInternalField(kDocumentImplementationIndex, wrapper);
return wrapper;
}
// --------------- Security Checks -------------------------
INDEXED_ACCESS_CHECK(History)
{
ASSERT(V8ClassIndex::FromInt(data->Int32Value()) == V8ClassIndex::HISTORY);
// Only allow same origin access.
History* history = V8DOMWrapper::convertToNativeObject<History>(V8ClassIndex::HISTORY, host);
return V8Proxy::canAccessFrame(history->frame(), false);
}
NAMED_ACCESS_CHECK(History)
{
ASSERT(V8ClassIndex::FromInt(data->Int32Value()) == V8ClassIndex::HISTORY);
// Only allow same origin access.
History* history = V8DOMWrapper::convertToNativeObject<History>(V8ClassIndex::HISTORY, host);
return V8Proxy::canAccessFrame(history->frame(), false);
}
#undef INDEXED_ACCESS_CHECK
#undef NAMED_ACCESS_CHECK
#undef NAMED_PROPERTY_GETTER
#undef NAMED_PROPERTY_SETTER
Frame* V8Custom::GetTargetFrame(v8::Local<v8::Object> host, v8::Local<v8::Value> data)
{
Frame* target = 0;
switch (V8ClassIndex::FromInt(data->Int32Value())) {
case V8ClassIndex::DOMWINDOW: {
v8::Handle<v8::Object> window = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, host);
if (window.IsEmpty())
return target;
DOMWindow* targetWindow = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, window);
target = targetWindow->frame();
break;
}
case V8ClassIndex::LOCATION: {
History* history = V8DOMWrapper::convertToNativeObject<History>(V8ClassIndex::HISTORY, host);
target = history->frame();
break;
}
case V8ClassIndex::HISTORY: {
Location* location = V8DOMWrapper::convertToNativeObject<Location>(V8ClassIndex::LOCATION, host);
target = location->frame();
break;
}
default:
break;
}
return target;
}
#if ENABLE(SVG)
V8ClassIndex::V8WrapperType V8Custom::DowncastSVGPathSeg(void* pathSeg)
{
WebCore::SVGPathSeg* realPathSeg = reinterpret_cast<WebCore::SVGPathSeg*>(pathSeg);
switch (realPathSeg->pathSegType()) {
#define MAKE_CASE(svgValue, v8Value) case WebCore::SVGPathSeg::svgValue: return V8ClassIndex::v8Value
MAKE_CASE(PATHSEG_CLOSEPATH, SVGPATHSEGCLOSEPATH);
MAKE_CASE(PATHSEG_MOVETO_ABS, SVGPATHSEGMOVETOABS);
MAKE_CASE(PATHSEG_MOVETO_REL, SVGPATHSEGMOVETOREL);
MAKE_CASE(PATHSEG_LINETO_ABS, SVGPATHSEGLINETOABS);
MAKE_CASE(PATHSEG_LINETO_REL, SVGPATHSEGLINETOREL);
MAKE_CASE(PATHSEG_CURVETO_CUBIC_ABS, SVGPATHSEGCURVETOCUBICABS);
MAKE_CASE(PATHSEG_CURVETO_CUBIC_REL, SVGPATHSEGCURVETOCUBICREL);
MAKE_CASE(PATHSEG_CURVETO_QUADRATIC_ABS, SVGPATHSEGCURVETOQUADRATICABS);
MAKE_CASE(PATHSEG_CURVETO_QUADRATIC_REL, SVGPATHSEGCURVETOQUADRATICREL);
MAKE_CASE(PATHSEG_ARC_ABS, SVGPATHSEGARCABS);
MAKE_CASE(PATHSEG_ARC_REL, SVGPATHSEGARCREL);
MAKE_CASE(PATHSEG_LINETO_HORIZONTAL_ABS, SVGPATHSEGLINETOHORIZONTALABS);
MAKE_CASE(PATHSEG_LINETO_HORIZONTAL_REL, SVGPATHSEGLINETOHORIZONTALREL);
MAKE_CASE(PATHSEG_LINETO_VERTICAL_ABS, SVGPATHSEGLINETOVERTICALABS);
MAKE_CASE(PATHSEG_LINETO_VERTICAL_REL, SVGPATHSEGLINETOVERTICALREL);
MAKE_CASE(PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, SVGPATHSEGCURVETOCUBICSMOOTHABS);
MAKE_CASE(PATHSEG_CURVETO_CUBIC_SMOOTH_REL, SVGPATHSEGCURVETOCUBICSMOOTHREL);
MAKE_CASE(PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, SVGPATHSEGCURVETOQUADRATICSMOOTHABS);
MAKE_CASE(PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, SVGPATHSEGCURVETOQUADRATICSMOOTHREL);
#undef MAKE_CASE
default:
return V8ClassIndex::INVALID_CLASS_INDEX;
}
}
#endif // ENABLE(SVG)
} // namespace WebCore