src/third_party/WebKit/Source/web/WebBindings.cpp

   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 using namespace blink;
  55
  56 namespace blink {
  57
  58 bool WebBindings::construct(NPP npp, NPObject* object, const NPVariant* args, uint32_t argCount, NPVariant* result)
  59 {
  60     return _NPN_Construct(npp, object, args, argCount, result);
  61 }
  62
  63 NPObject* WebBindings::createObject(NPP npp, NPClass* npClass)
  64 {
  65     return _NPN_CreateObject(npp, npClass);
  66 }
  67
  68 bool WebBindings::enumerate(NPP npp, NPObject* object, NPIdentifier** identifier, uint32_t* identifierCount)
  69 {
  70     return _NPN_Enumerate(npp, object, identifier, identifierCount);
  71 }
  72
  73 bool WebBindings::evaluate(NPP npp, NPObject* object, NPString* script, NPVariant* result)
  74 {
  75     return _NPN_Evaluate(npp, object, script, result);
  76 }
  77
  78 bool WebBindings::evaluateHelper(NPP npp, bool popupsAllowed, NPObject* object, NPString* script, NPVariant* result)
  79 {
  80     return _NPN_EvaluateHelper(npp, popupsAllowed, object, script, result);
  81 }
  82
  83 NPIdentifier WebBindings::getIntIdentifier(int32_t number)
  84 {
  85     return _NPN_GetIntIdentifier(number);
  86 }
  87
  88 bool WebBindings::getProperty(NPP npp, NPObject* object, NPIdentifier property, NPVariant* result)
  89 {
  90     return _NPN_GetProperty(npp, object, property, result);
  91 }
  92
  93 NPIdentifier WebBindings::getStringIdentifier(const NPUTF8* string)
  94 {
  95     return _NPN_GetStringIdentifier(string);
  96 }
  97
  98 void WebBindings::getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
  99 {
 100     _NPN_GetStringIdentifiers(names, nameCount, identifiers);
 101 }
 102
 103 bool WebBindings::hasMethod(NPP npp, NPObject* object, NPIdentifier method)
 104 {
 105     return _NPN_HasMethod(npp, object, method);
 106 }
 107
 108 bool WebBindings::hasProperty(NPP npp, NPObject* object, NPIdentifier property)
 109 {
 110     return _NPN_HasProperty(npp, object, property);
 111 }
 112
 113 bool WebBindings::identifierIsString(NPIdentifier identifier)
 114 {
 115     return _NPN_IdentifierIsString(identifier);
 116 }
 117
 118 int32_t WebBindings::intFromIdentifier(NPIdentifier identifier)
 119 {
 120     return _NPN_IntFromIdentifier(identifier);
 121 }
 122
 123 void WebBindings::initializeVariantWithStringCopy(NPVariant* variant, const NPString* value)
 124 {
 125     _NPN_InitializeVariantWithStringCopy(variant, value);
 126 }
 127
 128 bool WebBindings::invoke(NPP npp, NPObject* object, NPIdentifier method, const NPVariant* args, uint32_t argCount, NPVariant* result)
 129 {
 130     return _NPN_Invoke(npp, object, method, args, argCount, result);
 131 }
 132
 133 bool WebBindings::invokeDefault(NPP npp, NPObject* object, const NPVariant* args, uint32_t argCount, NPVariant* result)
 134 {
 135     return _NPN_InvokeDefault(npp, object, args, argCount, result);
 136 }
 137
 138 void WebBindings::releaseObject(NPObject* object)
 139 {
 140     return _NPN_ReleaseObject(object);
 141 }
 142
 143 void WebBindings::releaseVariantValue(NPVariant* variant)
 144 {
 145     _NPN_ReleaseVariantValue(variant);
 146 }
 147
 148 bool WebBindings::removeProperty(NPP npp, NPObject* object, NPIdentifier identifier)
 149 {
 150     return _NPN_RemoveProperty(npp, object, identifier);
 151 }
 152
 153 NPObject* WebBindings::retainObject(NPObject* object)
 154 {
 155     return _NPN_RetainObject(object);
 156 }
 157
 158 void WebBindings::setException(NPObject* object, const NPUTF8* message)
 159 {
 160     _NPN_SetException(object, message);
 161 }
 162
 163 bool WebBindings::setProperty(NPP npp, NPObject* object, NPIdentifier identifier, const NPVariant* value)
 164 {
 165     return _NPN_SetProperty(npp, object, identifier, value);
 166 }
 167
 168 void WebBindings::registerObjectOwner(NPP)
 169 {
 170 }
 171
 172 void WebBindings::unregisterObjectOwner(NPP)
 173 {
 174 }
 175
 176 NPP WebBindings::getObjectOwner(NPObject*)
 177 {
 178     return 0;
 179 }
 180
 181 void WebBindings::unregisterObject(NPObject* object)
 182 {
 183     _NPN_UnregisterObject(object);
 184 }
 185
 186 void WebBindings::dropV8WrapperForObject(NPObject* object)
 187 {
 188     blink::forgetV8ObjectForNPObject(object);
 189 }
 190
 191 NPUTF8* WebBindings::utf8FromIdentifier(NPIdentifier identifier)
 192 {
 193     return _NPN_UTF8FromIdentifier(identifier);
 194 }
 195
 196 void WebBindings::extractIdentifierData(const NPIdentifier& identifier, const NPUTF8*& string, int32_t& number, bool& isString)
 197 {
 198     PrivateIdentifier* data = static_cast<PrivateIdentifier*>(identifier);
 199     if (!data) {
 200         isString = false;
 201         number = 0;
 202         return;
 203     }
 204
 205     isString = data->isString;
 206     if (isString)
 207         string = data->value.string;
 208     else
 209         number = data->value.number;
 210 }
 211
 212 static bool getRangeImpl(NPObject* object, WebRange* webRange, v8::Isolate* isolate)
 213 {
 214     if (!object)
 215         return false;
 216
 217     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
 218     if (!v8NPObject)
 219         return false;
 220
 221     v8::HandleScope handleScope(isolate);
 222     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 223     if (v8Object.IsEmpty())
 224         return false;
 225     if (!V8Range::wrapperTypeInfo.equals(toWrapperTypeInfo(v8Object)))
 226         return false;
 227
 228     Range* native = V8Range::hasInstance(v8Object, isolate) ? V8Range::toNative(v8Object) : 0;
 229     if (!native)
 230         return false;
 231
 232     *webRange = WebRange(native);
 233     return true;
 234 }
 235
 236 static bool getNodeImpl(NPObject* object, WebNode* webNode, v8::Isolate* isolate)
 237 {
 238     if (!object)
 239         return false;
 240
 241     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
 242     if (!v8NPObject)
 243         return false;
 244
 245     v8::HandleScope handleScope(isolate);
 246     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 247     if (v8Object.IsEmpty())
 248         return false;
 249     Node* native = V8Node::hasInstance(v8Object, isolate) ? V8Node::toNative(v8Object) : 0;
 250     if (!native)
 251         return false;
 252
 253     *webNode = WebNode(native);
 254     return true;
 255 }
 256
 257 static bool getElementImpl(NPObject* object, WebElement* webElement, v8::Isolate* isolate)
 258 {
 259     if (!object)
 260         return false;
 261
 262     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
 263     if (!v8NPObject)
 264         return false;
 265
 266     v8::HandleScope handleScope(isolate);
 267     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 268     if (v8Object.IsEmpty())
 269         return false;
 270     Element* native = V8Element::hasInstance(v8Object, isolate) ? V8Element::toNative(v8Object) : 0;
 271     if (!native)
 272         return false;
 273
 274     *webElement = WebElement(native);
 275     return true;
 276 }
 277
 278 static bool getArrayBufferImpl(NPObject* object, WebArrayBuffer* arrayBuffer, v8::Isolate* isolate)
 279 {
 280     if (!object)
 281         return false;
 282
 283     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
 284     if (!v8NPObject)
 285         return false;
 286
 287     v8::HandleScope handleScope(isolate);
 288     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 289     if (v8Object.IsEmpty())
 290         return false;
 291     ArrayBuffer* native = V8ArrayBuffer::hasInstance(v8Object, isolate) ? V8ArrayBuffer::toNative(v8Object) : 0;
 292     if (!native)
 293         return false;
 294
 295     *arrayBuffer = WebArrayBuffer(native);
 296     return true;
 297 }
 298
 299 static bool getArrayBufferViewImpl(NPObject* object, WebArrayBufferView* arrayBufferView, v8::Isolate* isolate)
 300 {
 301     if (!object)
 302         return false;
 303
 304     V8NPObject* v8NPObject = npObjectToV8NPObject(object);
 305     if (!v8NPObject)
 306         return false;
 307
 308     v8::HandleScope handleScope(isolate);
 309     v8::Handle<v8::Object> v8Object = v8::Local<v8::Object>::New(isolate, v8NPObject->v8Object);
 310     if (v8Object.IsEmpty())
 311         return false;
 312     ArrayBufferView* native = V8ArrayBufferView::hasInstance(v8Object, isolate) ? V8ArrayBufferView::toNative(v8Object) : 0;
 313     if (!native)
 314         return false;
 315
 316     *arrayBufferView = WebArrayBufferView(native);
 317     return true;
 318 }
 319
 320 static NPObject* makeIntArrayImpl(const WebVector<int>& data, v8::Isolate* isolate)
 321 {
 322     v8::HandleScope handleScope(isolate);
 323     v8::Handle<v8::Array> result = v8::Array::New(isolate, data.size());
 324     for (size_t i = 0; i < data.size(); ++i)
 325         result->Set(i, v8::Number::New(isolate, data[i]));
 326
 327     LocalDOMWindow* window = currentDOMWindow(isolate);
 328     return npCreateV8ScriptObject(0, result, window, isolate);
 329 }
 330
 331 static NPObject* makeStringArrayImpl(const WebVector<WebString>& data, v8::Isolate* isolate)
 332 {
 333     v8::HandleScope handleScope(isolate);
 334     v8::Handle<v8::Array> result = v8::Array::New(isolate, data.size());
 335     for (size_t i = 0; i < data.size(); ++i)
 336         result->Set(i, v8String(isolate, data[i]));
 337
 338     LocalDOMWindow* window = currentDOMWindow(isolate);
 339     return npCreateV8ScriptObject(0, result, window, isolate);
 340 }
 341
 342 bool WebBindings::getRange(NPObject* range, WebRange* webRange)
 343 {
 344     return getRangeImpl(range, webRange, v8::Isolate::GetCurrent());
 345 }
 346
 347 bool WebBindings::getArrayBuffer(NPObject* arrayBuffer, WebArrayBuffer* webArrayBuffer)
 348 {
 349     return getArrayBufferImpl(arrayBuffer, webArrayBuffer, v8::Isolate::GetCurrent());
 350 }
 351
 352 bool WebBindings::getArrayBufferView(NPObject* arrayBufferView, WebArrayBufferView* webArrayBufferView)
 353 {
 354     return getArrayBufferViewImpl(arrayBufferView, webArrayBufferView, v8::Isolate::GetCurrent());
 355 }
 356
 357 bool WebBindings::getNode(NPObject* node, WebNode* webNode)
 358 {
 359     return getNodeImpl(node, webNode, v8::Isolate::GetCurrent());
 360 }
 361
 362 bool WebBindings::getElement(NPObject* element, WebElement* webElement)
 363 {
 364     return getElementImpl(element, webElement, v8::Isolate::GetCurrent());
 365 }
 366
 367 NPObject* WebBindings::makeIntArray(const WebVector<int>& data)
 368 {
 369     return makeIntArrayImpl(data, v8::Isolate::GetCurrent());
 370 }
 371
 372 NPObject* WebBindings::makeStringArray(const WebVector<WebString>& data)
 373 {
 374     return makeStringArrayImpl(data, v8::Isolate::GetCurrent());
 375 }
 376
 377 void WebBindings::pushExceptionHandler(ExceptionHandler handler, void* data)
 378 {
 379     blink::pushExceptionHandler(handler, data);
 380 }
 381
 382 void WebBindings::popExceptionHandler()
 383 {
 384     blink::popExceptionHandler();
 385 }
 386
 387 void WebBindings::toNPVariant(v8::Local<v8::Value> object, NPObject* root, NPVariant* result)
 388 {
 389     blink::convertV8ObjectToNPVariant(object, root, result, v8::Isolate::GetCurrent());
 390 }
 391
 392 v8::Handle<v8::Value> WebBindings::toV8Value(const NPVariant* variant)
 393 {
 394     v8::Isolate* isolate = v8::Isolate::GetCurrent();
 395     if (variant->type == NPVariantType_Object) {
 396         NPObject* object = NPVARIANT_TO_OBJECT(*variant);
 397         V8NPObject* v8Object = npObjectToV8NPObject(object);
 398         if (!v8Object)
 399             return v8::Undefined(isolate);
 400         return convertNPVariantToV8Object(variant, v8Object->rootObject->frame()->script().windowScriptNPObject(), isolate);
 401     }
 402     // Safe to pass 0 since we have checked the script object class to make sure the
 403     // argument is a primitive v8 type.
 404     return convertNPVariantToV8Object(variant, 0, isolate);
 405 }
 406
 407 } // namespace blink