Home | History | Annotate | Download | only in web 
      1 /*
      2  * Copyright (C) 2009 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "config.h"
     32 #include "public/web/WebBindings.h"
     33 
     34 #include "bindings/core/v8/NPV8Object.h"
     35 #include "bindings/core/v8/ScriptController.h"
     36 #include "bindings/core/v8/V8DOMWrapper.h"
     37 #include "bindings/core/v8/V8Element.h"
     38 #include "bindings/core/v8/V8NPObject.h"
     39 #include "bindings/core/v8/V8NPUtils.h"
     40 #include "bindings/core/v8/V8Range.h"
     41 #include "bindings/core/v8/custom/V8ArrayBufferCustom.h"
     42 #include "bindings/core/v8/custom/V8ArrayBufferViewCustom.h"
     43 #include "bindings/core/v8/npruntime_impl.h"
     44 #include "bindings/core/v8/npruntime_priv.h"
     45 #include "core/dom/Range.h"
     46 #include "core/frame/LocalDOMWindow.h"
     47 #include "core/frame/LocalFrame.h"
     48 #include "public/platform/WebArrayBuffer.h"
     49 #include "public/web/WebArrayBufferView.h"
     50 #include "public/web/WebElement.h"
     51 #include "public/web/WebRange.h"
     52 #include "wtf/ArrayBufferView.h"
     53 
     54 namespace blink {
     55 
     56 bool WebBindings::construct(NPP npp, NPObject* object, const NPVariant* args, uint32_t argCount, NPVariant* result)
     57 {
     58     return _NPN_Construct(npp, object, args, argCount, result);
     59 }
     60 
     61 NPObject* WebBindings::createObject(NPP npp, NPClass* npClass)
     62 {
     63     return _NPN_CreateObject(npp, npClass);
     64 }
     65 
     66 bool WebBindings::enumerate(NPP npp, NPObject* object, NPIdentifier** identifier, uint32_t* identifierCount)
     67 {
     68     return _NPN_Enumerate(npp, object, identifier, identifierCount);
     69 }
     70 
     71 bool WebBindings::evaluate(NPP npp, NPObject* object, NPString* script, NPVariant* result)
     72 {
     73     return _NPN_Evaluate(npp, object, script, result);
     74 }
     75 
     76 bool WebBindings::evaluateHelper(NPP npp, bool popupsAllowed, NPObject* object, NPString* script, NPVariant* result)
     77 {
     78     return _NPN_EvaluateHelper(npp, popupsAllowed, object, script, result);
     79 }
     80 
     81 NPIdentifier WebBindings::getIntIdentifier(int32_t number)
     82 {
     83     return _NPN_GetIntIdentifier(number);
     84 }
     85 
     86 bool WebBindings::getProperty(NPP npp, NPObject* object, NPIdentifier property, NPVariant* result)
     87 {
     88     return _NPN_GetProperty(npp, object, property, result);
     89 }
     90 
     91 NPIdentifier WebBindings::getStringIdentifier(const NPUTF8* string)
     92 {
     93     return _NPN_GetStringIdentifier(string);
     94 }
     95 
     96 void WebBindings::getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
     97 {
     98     _NPN_GetStringIdentifiers(names, nameCount, identifiers);
     99 }
    100 
    101 bool WebBindings::hasMethod(NPP npp, NPObject* object, NPIdentifier method)
    102 {
    103     return _NPN_HasMethod(npp, object, method);
    104 }
    105 
    106 bool WebBindings::hasProperty(NPP npp, NPObject* object, NPIdentifier property)
    107 {
    108     return _NPN_HasProperty(npp, object, property);
    109 }
    110 
    111 bool WebBindings::identifierIsString(NPIdentifier identifier)
    112 {
    113     return _NPN_IdentifierIsString(identifier);
    114 }
    115 
    116 int32_t WebBindings::intFromIdentifier(NPIdentifier identifier)
    117 {
    118     return _NPN_IntFromIdentifier(identifier);
    119 }
    120 
    121 void WebBindings::initializeVariantWithStringCopy(NPVariant* variant, const NPString* value)
    122 {
    123     _NPN_InitializeVariantWithStringCopy(variant, value);
    124 }
    125 
    126 bool WebBindings::invoke(NPP npp, NPObject* object, NPIdentifier method, const NPVariant* args, uint32_t argCount, NPVariant* result)
    127 {
    128     return _NPN_Invoke(npp, object, method, args, argCount, result);
    129 }
    130 
    131 bool WebBindings::invokeDefault(NPP npp, NPObject* object, const NPVariant* args, uint32_t argCount, NPVariant* result)
    132 {
    133     return _NPN_InvokeDefault(npp, object, args, argCount, result);
    134 }
    135 
    136 void WebBindings::releaseObject(NPObject* object)
    137 {
    138     return _NPN_ReleaseObject(object);
    139 }
    140 
    141 void WebBindings::releaseVariantValue(NPVariant* variant)
    142 {
    143     _NPN_ReleaseVariantValue(variant);
    144 }
    145 
    146 bool WebBindings::removeProperty(NPP npp, NPObject* object, NPIdentifier identifier)
    147 {
    148     return _NPN_RemoveProperty(npp, object, identifier);
    149 }
    150 
    151 NPObject* WebBindings::retainObject(NPObject* object)
    152 {
    153     return _NPN_RetainObject(object);
    154 }
    155 
    156 void WebBindings::setException(NPObject* object, const NPUTF8* message)
    157 {
    158     _NPN_SetException(object, message);
    159 }
    160 
    161 bool WebBindings::setProperty(NPP npp, NPObject* object, NPIdentifier identifier, const NPVariant* value)
    162 {
    163     return _NPN_SetProperty(npp, object, identifier, value);
    164 }
    165 
    166 void WebBindings::registerObjectOwner(NPP)
    167 {
    168 }
    169 
    170 void WebBindings::unregisterObjectOwner(NPP)
    171 {
    172 }
    173 
    174 NPP WebBindings::getObjectOwner(NPObject*)
    175 {
    176     return 0;
    177 }
    178 
    179 void WebBindings::unregisterObject(NPObject* object)
    180 {
    181     _NPN_UnregisterObject(object);
    182 }
    183 
    184 void WebBindings::dropV8WrapperForObject(NPObject* object)
    185 {
    186     forgetV8ObjectForNPObject(object);
    187 }
    188 
    189 NPUTF8* WebBindings::utf8FromIdentifier(NPIdentifier identifier)
    190 {
    191     return _NPN_UTF8FromIdentifier(identifier);
    192 }
    193 
    194 void WebBindings::extractIdentifierData(const NPIdentifier& identifier, const NPUTF8*& string, int32_t& number, bool& isString)
    195 {
    196     PrivateIdentifier* data = static_cast<PrivateIdentifier*>(identifier);
    197     if (!data) {
    198         isString = false;
    199         number = 0;
    200         return;
    201     }
    202 
    203     isString = data->isString;
    204     if (isString)
    205         string = data->value.string;
    206     else
    207         number = data->value.number;
    208 }
    209 
    210 static bool getRangeImpl(NPObject* object, WebRange* webRange, v8::Isolate* isolate)
    211 {
    212     if (!object)
    213         return false;
    214 
    215     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
    216     if (!v8NPObject)
    217         return false;
    218 
    219     v8::HandleScope handleScope(isolate);
    220     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
    221     if (v8Object.IsEmpty())
    222         return false;
    223     if (!V8Range::wrapperTypeInfo.equals(toWrapperTypeInfo(v8Object)))
    224         return false;
    225 
    226     Range* native = V8Range::hasInstance(v8Object, isolate) ? V8Range::toImpl(v8Object) : 0;
    227     if (!native)
    228         return false;
    229 
    230     *webRange = WebRange(native);
    231     return true;
    232 }
    233 
    234 static bool getNodeImpl(NPObject* object, WebNode* webNode, v8::Isolate* isolate)
    235 {
    236     if (!object)
    237         return false;
    238 
    239     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
    240     if (!v8NPObject)
    241         return false;
    242 
    243     v8::HandleScope handleScope(isolate);
    244     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
    245     if (v8Object.IsEmpty())
    246         return false;
    247     Node* native = V8Node::hasInstance(v8Object, isolate) ? V8Node::toImpl(v8Object) : 0;
    248     if (!native)
    249         return false;
    250 
    251     *webNode = WebNode(native);
    252     return true;
    253 }
    254 
    255 static bool getElementImpl(NPObject* object, WebElement* webElement, v8::Isolate* isolate)
    256 {
    257     if (!object)
    258         return false;
    259 
    260     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
    261     if (!v8NPObject)
    262         return false;
    263 
    264     v8::HandleScope handleScope(isolate);
    265     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
    266     if (v8Object.IsEmpty())
    267         return false;
    268     Element* native = V8Element::hasInstance(v8Object, isolate) ? V8Element::toImpl(v8Object) : 0;
    269     if (!native)
    270         return false;
    271 
    272     *webElement = WebElement(native);
    273     return true;
    274 }
    275 
    276 static bool getArrayBufferImpl(NPObject* object, WebArrayBuffer* arrayBuffer, v8::Isolate* isolate)
    277 {
    278     if (!object)
    279         return false;
    280 
    281     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
    282     if (!v8NPObject)
    283         return false;
    284 
    285     v8::HandleScope handleScope(isolate);
    286     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
    287     if (v8Object.IsEmpty())
    288         return false;
    289     ArrayBuffer* native = V8ArrayBuffer::hasInstance(v8Object, isolate) ? V8ArrayBuffer::toImpl(v8Object) : 0;
    290     if (!native)
    291         return false;
    292 
    293     *arrayBuffer = WebArrayBuffer(native);
    294     return true;
    295 }
    296 
    297 static bool getArrayBufferViewImpl(NPObject* object, WebArrayBufferView* arrayBufferView, v8::Isolate* isolate)
    298 {
    299     if (!object)
    300         return false;
    301 
    302     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
    303     if (!v8NPObject)
    304         return false;
    305 
    306     v8::HandleScope handleScope(isolate);
    307     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
    308     if (v8Object.IsEmpty())
    309         return false;
    310     ArrayBufferView* native = V8ArrayBufferView::hasInstance(v8Object, isolate) ? V8ArrayBufferView::toImpl(v8Object) : 0;
    311     if (!native)
    312         return false;
    313 
    314     *arrayBufferView = WebArrayBufferView(native);
    315     return true;
    316 }
    317 
    318 static NPObject* makeIntArrayImpl(const WebVector<int>& data, v8::Isolate* isolate)
    319 {
    320     v8::HandleScope handleScope(isolate);
    321     v8::Handle<v8::Array> result = v8::Array::New(isolate, data.size());
    322     for (size_t i = 0; i < data.size(); ++i)
    323         result->Set(i, v8::Number::New(isolate, data[i]));
    324 
    325     LocalDOMWindow* window = currentDOMWindow(isolate);
    326     return npCreateV8ScriptObject(0, result, window, isolate);
    327 }
    328 
    329 static NPObject* makeStringArrayImpl(const WebVector<WebString>& data, v8::Isolate* isolate)
    330 {
    331     v8::HandleScope handleScope(isolate);
    332     v8::Handle<v8::Array> result = v8::Array::New(isolate, data.size());
    333     for (size_t i = 0; i < data.size(); ++i)
    334         result->Set(i, v8String(isolate, data[i]));
    335 
    336     LocalDOMWindow* window = currentDOMWindow(isolate);
    337     return npCreateV8ScriptObject(0, result, window, isolate);
    338 }
    339 
    340 bool WebBindings::getRange(NPObject* range, WebRange* webRange)
    341 {
    342     return getRangeImpl(range, webRange, v8::Isolate::GetCurrent());
    343 }
    344 
    345 bool WebBindings::getArrayBuffer(NPObject* arrayBuffer, WebArrayBuffer* webArrayBuffer)
    346 {
    347     return getArrayBufferImpl(arrayBuffer, webArrayBuffer, v8::Isolate::GetCurrent());
    348 }
    349 
    350 bool WebBindings::getArrayBufferView(NPObject* arrayBufferView, WebArrayBufferView* webArrayBufferView)
    351 {
    352     return getArrayBufferViewImpl(arrayBufferView, webArrayBufferView, v8::Isolate::GetCurrent());
    353 }
    354 
    355 bool WebBindings::getNode(NPObject* node, WebNode* webNode)
    356 {
    357     return getNodeImpl(node, webNode, v8::Isolate::GetCurrent());
    358 }
    359 
    360 bool WebBindings::getElement(NPObject* element, WebElement* webElement)
    361 {
    362     return getElementImpl(element, webElement, v8::Isolate::GetCurrent());
    363 }
    364 
    365 NPObject* WebBindings::makeIntArray(const WebVector<int>& data)
    366 {
    367     return makeIntArrayImpl(data, v8::Isolate::GetCurrent());
    368 }
    369 
    370 NPObject* WebBindings::makeStringArray(const WebVector<WebString>& data)
    371 {
    372     return makeStringArrayImpl(data, v8::Isolate::GetCurrent());
    373 }
    374 
    375 void WebBindings::pushExceptionHandler(ExceptionHandler handler, void* data)
    376 {
    377     blink::pushExceptionHandler(handler, data);
    378 }
    379 
    380 void WebBindings::popExceptionHandler()
    381 {
    382     blink::popExceptionHandler();
    383 }
    384 
    385 void WebBindings::toNPVariant(v8::Local<v8::Value> object, NPObject* root, NPVariant* result)
    386 {
    387     convertV8ObjectToNPVariant(object, root, result, v8::Isolate::GetCurrent());
    388 }
    389 
    390 v8::Handle<v8::Value> WebBindings::toV8Value(const NPVariant* variant)
    391 {
    392     v8::Isolate* isolate = v8::Isolate::GetCurrent();
    393     if (variant->type == NPVariantType_Object) {
    394         NPObject* object = NPVARIANT_TO_OBJECT(*variant);
    395         V8NPObject* v8Object = npObjectToV8NPObject(object);
    396         if (!v8Object)
    397             return v8::Undefined(isolate);
    398         return convertNPVariantToV8Object(variant, v8Object->rootObject->frame()->script().windowScriptNPObject(), isolate);
    399     }
    400     // Safe to pass 0 since we have checked the script object class to make sure the
    401     // argument is a primitive v8 type.
    402     return convertNPVariantToV8Object(variant, 0, isolate);
    403 }
    404 
    405 } // namespace blink
    406