Moved files under Source/bindings/v8 to Source/bindings/core/v8.

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 11 matching lines @@
  * 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 "bindings/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/SerializedScriptValue.h"
 
+#include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
+#include "bindings/core/v8/WorkerScriptController.h"
 #include "bindings/core/v8/custom/V8ArrayBufferCustom.h"
 #include "bindings/core/v8/custom/V8ArrayBufferViewCustom.h"
 #include "bindings/core/v8/custom/V8DataViewCustom.h"
 #include "bindings/core/v8/custom/V8Float32ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Float64ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Int16ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Int32ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Int8ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Uint16ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Uint32ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Uint8ArrayCustom.h"
 #include "bindings/core/v8/custom/V8Uint8ClampedArrayCustom.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
 #include "bindings/modules/v8/V8DOMFileSystem.h"
-#include "bindings/v8/ExceptionState.h"
-#include "bindings/v8/V8Binding.h"
-#include "bindings/v8/WorkerScriptController.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/MessagePort.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/DataView.h"
 #include "platform/SharedBuffer.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
@@ skipping 298 matching lines @@
     {
         int stringLength = string->Length();
         int utf8Length = string->Utf8Length();
         ASSERT(stringLength >= 0 && utf8Length >= 0);
 
         append(StringTag);
         doWriteUint32(static_cast<uint32_t>(utf8Length));
         ensureSpace(utf8Length);
 
         // ASCII fast path.
-        if (stringLength == utf8Length)
+        if (stringLength == utf8Length) {
             string->WriteOneByte(byteAt(m_position), 0, utf8Length, v8StringWriteOptions());
-        else {
+        } else {
             char* buffer = reinterpret_cast<char*>(byteAt(m_position));
             string->WriteUtf8(buffer, utf8Length, 0, v8StringWriteOptions());
         }
         m_position += utf8Length;
     }
 
     void writeUCharString(v8::Handle<v8::String>& string)
     {
         int length = string->Length();
         ASSERT(length >= 0);
@@ skipping 690 matching lines @@
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
                     if (propertyName.IsEmpty())
                         return serializer.handleError(InputError, "Empty property names cannot be cloned.", this);
                     bool hasStringProperty = propertyName->IsString() && composite()->HasRealNamedProperty(propertyName.As<v8::String>());
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
                     bool hasIndexedProperty = !hasStringProperty && propertyName->IsUint32() && composite()->HasRealIndexedProperty(propertyName->Uint32Value());
                     if (StateBase* newState = serializer.checkException(this))
                         return newState;
-                    if (hasStringProperty || (hasIndexedProperty && !ignoreIndexed))
+                    if (hasStringProperty || (hasIndexedProperty && !ignoreIndexed)) {
                         m_propertyName = propertyName;
-                    else {
+                    } else {
                         ++m_index;
                         continue;
                     }
                 }
                 ASSERT(!m_propertyName.IsEmpty());
                 if (!m_nameDone) {
                     m_nameDone = true;
                     if (StateBase* newState = serializer.doSerialize(m_propertyName, this))
                         return newState;
                 }
@@ skipping 415 matching lines @@
     uint32_t objectReference;
     uint32_t arrayBufferIndex;
     if ((value->IsObject() || value->IsDate() || value->IsRegExp())
         && m_objectPool.tryGet(value.As<v8::Object>(), &objectReference)) {
         // Note that IsObject() also detects wrappers (eg, it will catch the things
         // that we grey and write below).
         ASSERT(!value->IsString());
         m_writer.writeObjectReference(objectReference);
     } else if (value.IsEmpty()) {
         return handleError(InputError, "The empty property name cannot be cloned.", next);
-    } else if (value->IsUndefined())
+    } else if (value->IsUndefined()) {
         m_writer.writeUndefined();
-    else if (value->IsNull())
+    } else if (value->IsNull()) {
         m_writer.writeNull();
-    else if (value->IsTrue())
+    } else if (value->IsTrue()) {
         m_writer.writeTrue();
-    else if (value->IsFalse())
+    } else if (value->IsFalse()) {
         m_writer.writeFalse();
-    else if (value->IsInt32())
+    } else if (value->IsInt32()) {
         m_writer.writeInt32(value->Int32Value());
-    else if (value->IsUint32())
+    } else if (value->IsUint32()) {
         m_writer.writeUint32(value->Uint32Value());
-    else if (value->IsNumber())
+    } else if (value->IsNumber()) {
         m_writer.writeNumber(value.As<v8::Number>()->Value());
-    else if (V8ArrayBufferView::hasInstance(value, isolate()))
+    } else if (V8ArrayBufferView::hasInstance(value, isolate())) {
         return writeAndGreyArrayBufferView(value.As<v8::Object>(), next);
-    else if (value->IsString())
+    } else if (value->IsString()) {
         writeString(value);
-    else if (V8MessagePort::hasInstance(value, isolate())) {
+    } else if (V8MessagePort::hasInstance(value, isolate())) {
         uint32_t messagePortIndex;
-        if (m_transferredMessagePorts.tryGet(value.As<v8::Object>(), &messagePortIndex))
-                m_writer.writeTransferredMessagePort(messagePortIndex);
-            else
-                return handleError(DataCloneError, "A MessagePort could not be cloned.", next);
-    } else if (V8ArrayBuffer::hasInstance(value, isolate()) && m_transferredArrayBuffers.tryGet(value.As<v8::Object>(), &arrayBufferIndex))
+        if (m_transferredMessagePorts.tryGet(value.As<v8::Object>(), &messagePortIndex)) {
+            m_writer.writeTransferredMessagePort(messagePortIndex);
+        } else {
+            return handleError(DataCloneError, "A MessagePort could not be cloned.", next);
+        }
+    } else if (V8ArrayBuffer::hasInstance(value, isolate()) && m_transferredArrayBuffers.tryGet(value.As<v8::Object>(), &arrayBufferIndex)) {
         return writeTransferredArrayBuffer(value, arrayBufferIndex, next);
-    else {
+    } else {
         v8::Handle<v8::Object> jsObject = value.As<v8::Object>();
         if (jsObject.IsEmpty())
             return handleError(DataCloneError, "An object could not be cloned.", next);
         greyObject(jsObject);
-        if (value->IsDate())
+        if (value->IsDate()) {
             m_writer.writeDate(value->NumberValue());
-        else if (value->IsStringObject())
+        } else if (value->IsStringObject()) {
             writeStringObject(value);
-        else if (value->IsNumberObject())
+        } else if (value->IsNumberObject()) {
             writeNumberObject(value);
-        else if (value->IsBooleanObject())
+        } else if (value->IsBooleanObject()) {
             writeBooleanObject(value);
-        else if (value->IsArray()) {
+        } else if (value->IsArray()) {
             return startArrayState(value.As<v8::Array>(), next);
-        } else if (V8File::hasInstance(value, isolate()))
+        } else if (V8File::hasInstance(value, isolate())) {
             return writeFile(value, next);
-        else if (V8Blob::hasInstance(value, isolate()))
+        } else if (V8Blob::hasInstance(value, isolate())) {
             return writeBlob(value, next);
-        else if (V8DOMFileSystem::hasInstance(value, isolate()))
+        } else if (V8DOMFileSystem::hasInstance(value, isolate())) {
             return writeDOMFileSystem(value, next);
-        else if (V8FileList::hasInstance(value, isolate()))
+        } else if (V8FileList::hasInstance(value, isolate())) {
             return writeFileList(value, next);
-        else if (V8CryptoKey::hasInstance(value, isolate())) {
+        } else if (V8CryptoKey::hasInstance(value, isolate())) {
             if (!writeCryptoKey(value))
                 return handleError(DataCloneError, "Couldn't serialize key data", next);
-        } else if (V8ImageData::hasInstance(value, isolate()))
+        } else if (V8ImageData::hasInstance(value, isolate())) {
             writeImageData(value);
-        else if (value->IsRegExp())
+        } else if (value->IsRegExp()) {
             writeRegExp(value);
-        else if (V8ArrayBuffer::hasInstance(value, isolate()))
+        } else if (V8ArrayBuffer::hasInstance(value, isolate())) {
             return writeArrayBuffer(value, next);
-        else if (value->IsObject()) {
+        } else if (value->IsObject()) {
             if (isHostObject(jsObject) || jsObject->IsCallable() || value->IsNativeError())
                 return handleError(DataCloneError, "An object could not be cloned.", next);
             return startObjectState(jsObject, next);
-        } else
+        } else {
             return handleError(DataCloneError, "A value could not be cloned.", next);
+        }
     }
     return 0;
 }
 
 // Interface used by Reader to create objects of composite types.
 class CompositeCreator {
 public:
     virtual ~CompositeCreator() { }
 
     virtual bool consumeTopOfStack(v8::Handle<v8::Value>*) = 0;
@@ skipping 1454 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 WebCore