bindings: Renames from/toInternalPointer, etc.

Source/bindings/core/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 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
@@ skipping 1260 matching lines @@
     }
 
     void writeBooleanObject(v8::Handle<v8::Value> value)
     {
         v8::Handle<v8::BooleanObject> booleanObject = value.As<v8::BooleanObject>();
         m_writer.writeBooleanObject(booleanObject->ValueOf());
     }
 
     StateBase* writeBlob(v8::Handle<v8::Value> value, StateBase* next)
     {
-        Blob* blob = V8Blob::toNative(value.As<v8::Object>());
+        Blob* blob = V8Blob::toImpl(value.As<v8::Object>());
         if (!blob)
             return 0;
         if (blob->hasBeenClosed())
             return handleError(DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
         int blobIndex = -1;
         m_blobDataHandles.set(blob->uuid(), blob->blobDataHandle());
         if (appendBlobInfo(blob->uuid(), blob->type(), blob->size(), &blobIndex))
             m_writer.writeBlobIndex(blobIndex);
         else
             m_writer.writeBlob(blob->uuid(), blob->type(), blob->size());
         return 0;
     }
 
     StateBase* writeDOMFileSystem(v8::Handle<v8::Value> value, StateBase* next)
     {
-        DOMFileSystem* fs = V8DOMFileSystem::toNative(value.As<v8::Object>());
+        DOMFileSystem* fs = V8DOMFileSystem::toImpl(value.As<v8::Object>());
         if (!fs)
             return 0;
         if (!fs->clonable())
             return handleError(DataCloneError, "A FileSystem object could not be cloned.", next);
         m_writer.writeDOMFileSystem(fs->type(), fs->name(), fs->rootURL().string());
         return 0;
     }
 
     StateBase* writeFile(v8::Handle<v8::Value> value, StateBase* next)
     {
-        File* file = V8File::toNative(value.As<v8::Object>());
+        File* file = V8File::toImpl(value.As<v8::Object>());
         if (!file)
             return 0;
         if (file->hasBeenClosed())
             return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
         int blobIndex = -1;
         m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
         if (appendFileInfo(file, &blobIndex)) {
             ASSERT(blobIndex >= 0);
             m_writer.writeFileIndex(blobIndex);
         } else {
             m_writer.writeFile(*file);
         }
         return 0;
     }
 
     StateBase* writeFileList(v8::Handle<v8::Value> value, StateBase* next)
     {
-        FileList* fileList = V8FileList::toNative(value.As<v8::Object>());
+        FileList* fileList = V8FileList::toImpl(value.As<v8::Object>());
         if (!fileList)
             return 0;
         unsigned length = fileList->length();
         Vector<int> blobIndices;
         for (unsigned i = 0; i < length; ++i) {
             int blobIndex = -1;
             const File* file = fileList->item(i);
             if (file->hasBeenClosed())
                 return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
             m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
             if (appendFileInfo(file, &blobIndex)) {
                 ASSERT(!i || blobIndex > 0);
                 ASSERT(blobIndex >= 0);
                 blobIndices.append(blobIndex);
             }
         }
         if (!blobIndices.isEmpty())
             m_writer.writeFileListIndex(blobIndices);
         else
             m_writer.writeFileList(*fileList);
         return 0;
     }
 
     bool writeCryptoKey(v8::Handle<v8::Value> value)
     {
-        CryptoKey* key = V8CryptoKey::toNative(value.As<v8::Object>());
+        CryptoKey* key = V8CryptoKey::toImpl(value.As<v8::Object>());
         if (!key)
             return false;
         return m_writer.writeCryptoKey(key->key());
     }
 
     void writeImageData(v8::Handle<v8::Value> value)
     {
-        ImageData* imageData = V8ImageData::toNative(value.As<v8::Object>());
+        ImageData* imageData = V8ImageData::toImpl(value.As<v8::Object>());
         if (!imageData)
             return;
         Uint8ClampedArray* pixelArray = imageData->data();
         m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
     }
 
     void writeRegExp(v8::Handle<v8::Value> value)
     {
         v8::Handle<v8::RegExp> regExp = value.As<v8::RegExp>();
         m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags());
     }
 
     StateBase* writeAndGreyArrayBufferView(v8::Handle<v8::Object> object, StateBase* next)
     {
         ASSERT(!object.IsEmpty());
-        ArrayBufferView* arrayBufferView = V8ArrayBufferView::toNative(object);
+        ArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
         if (!arrayBufferView)
             return 0;
         if (!arrayBufferView->buffer())
             return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         v8::Handle<v8::Value> underlyingBuffer = toV8(arrayBufferView->buffer(), m_scriptState->context()->Global(), isolate());
         if (underlyingBuffer.IsEmpty())
             return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
         StateBase* stateOut = doSerializeArrayBuffer(underlyingBuffer, next);
         if (stateOut)
             return stateOut;
         m_writer.writeArrayBufferView(*arrayBufferView);
         // This should be safe: we serialize something that we know to be a wrapper (see
         // the toV8 call above), so the call to doSerializeArrayBuffer should neither
         // cause the system stack to overflow nor should it have potential to reach
         // this ArrayBufferView again.
         //
         // We do need to grey the underlying buffer before we grey its view, however;
         // ArrayBuffers may be shared, so they need to be given reference IDs, and an
         // ArrayBufferView cannot be constructed without a corresponding ArrayBuffer
         // (or without an additional tag that would allow us to do two-stage construction
         // like we do for Objects and Arrays).
         greyObject(object);
         return 0;
     }
 
     StateBase* writeArrayBuffer(v8::Handle<v8::Value> value, StateBase* next)
     {
-        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(value.As<v8::Object>());
+        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
             return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         ASSERT(!m_transferredArrayBuffers.contains(value.As<v8::Object>()));
         m_writer.writeArrayBuffer(*arrayBuffer);
         return 0;
     }
 
     StateBase* writeTransferredArrayBuffer(v8::Handle<v8::Value> value, uint32_t index, StateBase* next)
     {
-        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toNative(value.As<v8::Object>());
+        ArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
         if (!arrayBuffer)
             return 0;
         if (arrayBuffer->isNeutered())
             return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
         m_writer.writeTransferredArrayBuffer(index);
         return 0;
     }
 
     static bool shouldSerializeDensely(uint32_t length, uint32_t propertyCount)
     {
@@ skipping 632 matching lines @@
         if (!readArrayBufferViewSubTag(&subTag))
             return false;
         if (!doReadUint32(&byteOffset))
             return false;
         if (!doReadUint32(&byteLength))
             return false;
         if (!creator.consumeTopOfStack(&arrayBufferV8Value))
             return false;
         if (arrayBufferV8Value.IsEmpty())
             return false;
-        arrayBuffer = V8ArrayBuffer::toNative(arrayBufferV8Value.As<v8::Object>());
+        arrayBuffer = V8ArrayBuffer::toImpl(arrayBufferV8Value.As<v8::Object>());
         if (!arrayBuffer)
             return false;
 
         v8::Handle<v8::Object> creationContext = m_scriptState->context()->Global();
         switch (subTag) {
         case ByteArrayTag:
             *value = toV8(Int8Array::create(arrayBuffer.release(), byteOffset, byteLength), creationContext, isolate());
             break;
         case UnsignedByteArrayTag:
             *value = toV8(Uint8Array::create(arrayBuffer.release(), byteOffset, byteLength), creationContext,  isolate());
@@ skipping 940 matching lines @@
     // Validate the passed array of transferrables.
     for (unsigned i = 0; i < length; ++i) {
         v8::Local<v8::Value> transferrable = transferrables->Get(i);
         // Validation of non-null objects, per HTML5 spec 10.3.3.
         if (isUndefinedOrNull(transferrable)) {
             exceptionState.throwDOMException(DataCloneError, "Value at index " + String::number(i) + " is an untransferable " + (transferrable->IsUndefined() ? "'undefined'" : "'null'") + " value.");
             return false;
         }
         // Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
         if (V8MessagePort::hasInstance(transferrable, isolate)) {
-            RefPtrWillBeRawPtr<MessagePort> port = V8MessagePort::toNative(v8::Handle<v8::Object>::Cast(transferrable));
+            RefPtrWillBeRawPtr<MessagePort> port = V8MessagePort::toImpl(v8::Handle<v8::Object>::Cast(transferrable));
             // Check for duplicate MessagePorts.
             if (ports.contains(port)) {
                 exceptionState.throwDOMException(DataCloneError, "Message port at index " + String::number(i) + " is a duplicate of an earlier port.");
                 return false;
             }
             ports.append(port.release());
         } else if (V8ArrayBuffer::hasInstance(transferrable, isolate)) {
-            RefPtr<ArrayBuffer> arrayBuffer = V8ArrayBuffer::toNative(v8::Handle<v8::Object>::Cast(transferrable));
+            RefPtr<ArrayBuffer> arrayBuffer = V8ArrayBuffer::toImpl(v8::Handle<v8::Object>::Cast(transferrable));
             if (arrayBuffers.contains(arrayBuffer)) {
                 exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is a duplicate of an earlier ArrayBuffer.");
                 return false;
             }
             arrayBuffers.append(arrayBuffer.release());
         } else {
             exceptionState.throwDOMException(DataCloneError, "Value at index " + String::number(i) + " does not have a transferable type.");
             return false;
         }
     }
@@ skipping 13 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace blink