[Binding] [Refactoring] Create Writer and Serializer in one method

third_party/WebKit/Source/bindings/core/v8/ScriptValueSerializer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/Transferables.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
@@ skipping 540 matching lines @@
 int SerializedScriptValueWriter::v8StringWriteOptions()
 {
     return v8::String::NO_NULL_TERMINATION;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::AbstractObjectState::serializeProperties(ScriptValueSerializer& serializer)
 {
     while (m_index < m_propertyNames->Length()) {
         v8::Local<v8::Value> propertyName;
         if (!m_propertyNames->Get(serializer.context(), m_index).ToLocal(&propertyName))
-            return serializer.handleError(JSException, "Failed to get a property while cloning an object.", this);
+            return serializer.handleError(Status::JSException, "Failed to get a property while cloning an object.", this);
 
         bool hasProperty = false;
         if (propertyName->IsString()) {
             hasProperty = v8CallBoolean(composite()->HasRealNamedProperty(serializer.context(), propertyName.As<v8::String>()));
         } else if (propertyName->IsUint32()) {
             hasProperty = v8CallBoolean(composite()->HasRealIndexedProperty(serializer.context(), propertyName.As<v8::Uint32>()->Value()));
         }
         if (StateBase* newState = serializer.checkException(this))
             return newState;
         if (!hasProperty) {
             ++m_index;
             continue;
         }
 
         // |propertyName| is v8::String or v8::Uint32, so its serialization cannot be recursive.
         serializer.doSerialize(propertyName, nullptr);
 
         v8::Local<v8::Value> value;
         if (!composite()->Get(serializer.context(), propertyName).ToLocal(&value))
-            return serializer.handleError(JSException, "Failed to get a property while cloning an object.", this);
+            return serializer.handleError(Status::JSException, "Failed to get a property while cloning an object.", this);
         ++m_index;
         ++m_numSerializedProperties;
         // If we return early here, it's either because we have pushed a new state onto the
         // serialization state stack or because we have encountered an error (and in both cases
         // we are unwinding the native stack).
         if (StateBase* newState = serializer.doSerialize(value, this))
             return newState;
     }
     return objectDone(m_numSerializedProperties, serializer);
 }
@@ skipping 10 matching lines @@
 ScriptValueSerializer::StateBase* ScriptValueSerializer::ObjectState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
 {
     return serializer.writeObject(numProperties, this);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::DenseArrayState::advance(ScriptValueSerializer& serializer)
 {
     while (m_arrayIndex < m_arrayLength) {
         v8::Local<v8::Value> value;
         if (!composite().As<v8::Array>()->Get(serializer.context(), m_arrayIndex).ToLocal(&value))
-            return serializer.handleError(JSException, "Failed to get an element while cloning an array.", this);
+            return serializer.handleError(Status::JSException, "Failed to get an element while cloning an array.", this);
         m_arrayIndex++;
         if (StateBase* newState = serializer.checkException(this))
             return newState;
         if (StateBase* newState = serializer.doSerialize(value, this))
             return newState;
     }
     return serializeProperties(serializer);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::DenseArrayState::objectDone(unsigned numProperties, ScriptValueSerializer& serializer)
@@ skipping 10 matching lines @@
 {
     return serializer.writeSparseArray(numProperties, composite().As<v8::Array>()->Length(), this);
 }
 
 template <typename T>
 ScriptValueSerializer::StateBase* ScriptValueSerializer::CollectionState<T>::advance(ScriptValueSerializer& serializer)
 {
     while (m_index < m_length) {
         v8::Local<v8::Value> value;
         if (!m_entries->Get(serializer.context(), m_index).ToLocal(&value))
-            return serializer.handleError(JSException, "Failed to get an element while cloning a collection.", this);
+            return serializer.handleError(Status::JSException, "Failed to get an element while cloning a collection.", this);
         m_index++;
         if (StateBase* newState = serializer.checkException(this))
             return newState;
         if (StateBase* newState = serializer.doSerialize(value, this))
             return newState;
     }
     return serializer.writeCollection<T>(m_length, this);
 }
 
 static v8::Local<v8::Object> toV8Object(MessagePort* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
@@ skipping 41 matching lines @@
 // HTML5 structured clone algorithm.
 static bool isHostObject(v8::Local<v8::Object> object)
 {
     // If the object has any internal fields, then we won't be able to serialize or deserialize
     // them; conveniently, this is also a quick way to detect DOM wrapper objects, because
     // the mechanism for these relies on data stored in these fields. We should
     // catch external array data as a special case.
     return object->InternalFieldCount();
 }
 
-ScriptValueSerializer::ScriptValueSerializer(SerializedScriptValueWriter& writer, const Transferables* transferables, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
+ScriptValueSerializer::ScriptValueSerializer(SerializedScriptValueWriter& writer, const Transferables* transferables, WebBlobInfoArray* blobInfo, ScriptState* scriptState)
     : m_scriptState(scriptState)
     , m_writer(writer)
-    , m_tryCatch(tryCatch)
+    , m_tryCatch(scriptState->isolate())
     , m_depth(0)
-    , m_status(Success)
+    , m_status(Status::Success)
     , m_nextObjectReference(0)
     , m_blobInfo(blobInfo)
-    , m_blobDataHandles(blobDataHandles)
+    , m_blobDataHandles(nullptr)
 {
-    ASSERT(!tryCatch.HasCaught());
+    DCHECK(!m_tryCatch.HasCaught());
     if (transferables)
         copyTransferables(*transferables);
 }
 
 void ScriptValueSerializer::copyTransferables(const Transferables& transferables)
 {
     v8::Local<v8::Object> creationContext = m_scriptState->context()->Global();
 
     // Also kept in separate ObjectPools, iterate and copy the contents
     // of each kind of transferable vector.
@@ skipping 20 matching lines @@
     }
 
     const auto& offscreenCanvases = transferables.offscreenCanvases;
     for (size_t i = 0; i < offscreenCanvases.size(); ++i) {
         v8::Local<v8::Object> v8OffscreenCanvas = toV8Object(offscreenCanvases[i].get(), creationContext, isolate());
         if (!m_transferredOffscreenCanvas.contains(v8OffscreenCanvas))
             m_transferredOffscreenCanvas.set(v8OffscreenCanvas, i);
     }
 }
 
-ScriptValueSerializer::Status ScriptValueSerializer::serialize(v8::Local<v8::Value> value)
+PassRefPtr<SerializedScriptValue> ScriptValueSerializer::serialize(v8::Local<v8::Value> value, Transferables* transferables, ExceptionState& exceptionState)
 {
+    RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::create();
+    m_blobDataHandles = &serializedValue->blobDataHandles();
+
     v8::HandleScope scope(isolate());
-    m_writer.writeVersion();
-    StateBase* state = doSerialize(value, 0);
+    writer().writeVersion();
+    StateBase* state = doSerialize(value, nullptr);
     while (state)
         state = state->advance(*this);
-    return m_status;
+
+    switch (m_status) {
+    case Status::Success:
+        transferData(transferables, exceptionState, serializedValue.get());
+        break;
+    case Status::InputError:
+    case Status::DataCloneError:
+        exceptionState.throwDOMException(blink::DataCloneError, errorMessage());
+        break;
+    case Status::JSException:
+        exceptionState.rethrowV8Exception(m_tryCatch.Exception());
+        break;
+    default:
+        NOTREACHED();
+    }
+
+    m_blobDataHandles = nullptr;
+
+    return serializedValue.release();
+}
+
+void ScriptValueSerializer::transferData(Transferables* transferables, ExceptionState& exceptionState, SerializedScriptValue* serializedValue)
+{
+    serializedValue->setData(m_writer.takeWireString());
+    DCHECK(serializedValue->data().impl()->hasOneRef());
+    if (!transferables)
+        return;
+
+    serializedValue->transferImageBitmaps(isolate(), transferables->imageBitmaps, exceptionState);
+    if (exceptionState.hadException())
+        return;
+    serializedValue->transferArrayBuffers(isolate(), transferables->arrayBuffers, exceptionState);
+    if (exceptionState.hadException())
+        return;
+    serializedValue->transferOffscreenCanvas(isolate(), transferables->offscreenCanvases, exceptionState);
 }
 
 // static
 String ScriptValueSerializer::serializeWTFString(const String& data)
 {
     SerializedScriptValueWriter valueWriter;
     valueWriter.writeWebCoreString(data);
     return valueWriter.takeWireString();
 }
 
 // static
 String ScriptValueSerializer::serializeNullValue()
 {
     SerializedScriptValueWriter valueWriter;
     valueWriter.writeNull();
     return valueWriter.takeWireString();
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerialize(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     m_writer.writeReferenceCount(m_nextObjectReference);
 
     if (value.IsEmpty())
-        return handleError(InputError, "The empty property cannot be cloned.", next);
+        return handleError(Status::InputError, "The empty property cannot be cloned.", next);
 
     uint32_t objectReference;
     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);
         return nullptr;
     }
@@ skipping 10 matching lines @@
         m_writer.writeFalse();
     } else if (value->IsInt32()) {
         m_writer.writeInt32(value.As<v8::Int32>()->Value());
     } else if (value->IsUint32()) {
         m_writer.writeUint32(value.As<v8::Uint32>()->Value());
     } else if (value->IsNumber()) {
         m_writer.writeNumber(value.As<v8::Number>()->Value());
     } else if (value->IsString()) {
         writeString(value);
     } else {
-        return handleError(DataCloneError, "A value could not be cloned.", next);
+        return handleError(Status::DataCloneError, "A value could not be cloned.", next);
     }
     return nullptr;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerializeObject(v8::Local<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     DCHECK(!object.IsEmpty());
 
 
     if (object->IsArrayBufferView()) {
         return writeAndGreyArrayBufferView(object, next);
     }
     if (object->IsArrayBuffer()) {
         return writeAndGreyArrayBuffer(object, next);
     }
     if (object->IsSharedArrayBuffer()) {
         uint32_t index;
         if (!m_transferredArrayBuffers.tryGet(object, &index)) {
-            return handleError(DataCloneError, "A SharedArrayBuffer could not be cloned.", next);
+            return handleError(Status::DataCloneError, "A SharedArrayBuffer could not be cloned.", next);
         }
         return writeTransferredSharedArrayBuffer(object, index, next);
     }
 
     // Transferable only objects
     if (V8MessagePort::hasInstance(object, isolate())) {
         uint32_t index;
         if (!m_transferredMessagePorts.tryGet(object, &index)) {
-            return handleError(DataCloneError, "A MessagePort could not be cloned.", next);
+            return handleError(Status::DataCloneError, "A MessagePort could not be cloned.", next);
         }
         m_writer.writeTransferredMessagePort(index);
         return nullptr;
     }
     if (V8OffscreenCanvas::hasInstance(object, isolate())) {
         uint32_t index;
         if (!m_transferredOffscreenCanvas.tryGet(object, &index)) {
-            return handleError(DataCloneError, "A OffscreenCanvas could not be cloned.", next);
+            return handleError(Status::DataCloneError, "A OffscreenCanvas could not be cloned.", next);
         }
         return writeTransferredOffscreenCanvas(object, index, next);
     }
     if (V8ImageBitmap::hasInstance(object, isolate())) {
         return writeAndGreyImageBitmap(object, next);
     }
 
     greyObject(object);
 
     if (object->IsDate()) {
@@ skipping 38 matching lines @@
     if (object->IsRegExp()) {
         writeRegExp(object);
         return nullptr;
     }
     if (V8CompositorProxy::hasInstance(object, isolate())) {
         return writeCompositorProxy(object, next);
     }
 
     // Since IsNativeError is expensive, this check should always be the last check.
     if (isHostObject(object) || object->IsCallable() || object->IsNativeError()) {
-        return handleError(DataCloneError, "An object could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An object could not be cloned.", next);
     }
 
     return startObjectState(object, next);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerializeArrayBuffer(v8::Local<v8::Value> arrayBuffer, ScriptValueSerializer::StateBase* next)
 {
     return doSerialize(arrayBuffer, next);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::checkException(ScriptValueSerializer::StateBase* state)
 {
-    return m_tryCatch.HasCaught() ? handleError(JSException, "", state) : 0;
+    return m_tryCatch.HasCaught() ? handleError(Status::JSException, "", state) : nullptr;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeObject(uint32_t numProperties, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeObject(numProperties);
     return pop(state);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeSparseArray(uint32_t numProperties, uint32_t length, ScriptValueSerializer::StateBase* state)
 {
@@ skipping 16 matching lines @@
 
 template <>
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeCollection<v8::Set>(uint32_t length, ScriptValueSerializer::StateBase* state)
 {
     m_writer.writeSet(length);
     return pop(state);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::handleError(ScriptValueSerializer::Status errorStatus, const String& message, ScriptValueSerializer::StateBase* state)
 {
-    ASSERT(errorStatus != Success);
+    DCHECK(errorStatus != Status::Success);
     m_status = errorStatus;
     m_errorMessage = message;
     while (state) {
         StateBase* tmp = state->nextState();
         delete state;
         state = tmp;
     }
     return new ErrorState;
 }
 
@@ skipping 39 matching lines @@
     v8::Local<v8::BooleanObject> booleanObject = value.As<v8::BooleanObject>();
     m_writer.writeBooleanObject(booleanObject->ValueOf());
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeBlob(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     Blob* blob = V8Blob::toImpl(value.As<v8::Object>());
     if (!blob)
         return 0;
     if (blob->isClosed())
-        return handleError(DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
+        return handleError(Status::DataCloneError, "A Blob object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
-    m_blobDataHandles.set(blob->uuid(), blob->blobDataHandle());
+    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;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeCompositorProxy(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     CompositorProxy* compositorProxy = V8CompositorProxy::toImpl(value.As<v8::Object>());
     if (!compositorProxy)
         return nullptr;
     if (!compositorProxy->connected())
-        return handleError(DataCloneError, "A CompositorProxy object has been disconnected, and could therefore not be cloned.", next);
+        return handleError(Status::DataCloneError, "A CompositorProxy object has been disconnected, and could therefore not be cloned.", next);
     m_writer.writeCompositorProxy(*compositorProxy);
     return nullptr;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeFile(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     File* file = V8File::toImpl(value.As<v8::Object>());
     if (!file)
         return 0;
     if (file->isClosed())
-        return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
+        return handleError(Status::DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
     int blobIndex = -1;
-    m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
+    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;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeFileList(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     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->isClosed())
-            return handleError(DataCloneError, "A File object has been closed, and could therefore not be cloned.", next);
-        m_blobDataHandles.set(file->uuid(), file->blobDataHandle());
+            return handleError(Status::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;
 }
 
 void ScriptValueSerializer::writeImageData(v8::Local<v8::Value> value)
 {
     ImageData* imageData = V8ImageData::toImpl(value.As<v8::Object>());
     if (!imageData)
         return;
     DOMUint8ClampedArray* pixelArray = imageData->data();
     m_writer.writeImageData(imageData->width(), imageData->height(), pixelArray->data(), pixelArray->length());
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyImageBitmap(v8::Local<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     ImageBitmap* imageBitmap = V8ImageBitmap::toImpl(object);
     if (!imageBitmap)
         return nullptr;
     if (imageBitmap->isNeutered())
-        return handleError(DataCloneError, "An ImageBitmap is detached and could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An ImageBitmap is detached and could not be cloned.", next);
 
     uint32_t index;
     if (m_transferredImageBitmaps.tryGet(object, &index)) {
         m_writer.writeTransferredImageBitmap(index);
     } else {
         greyObject(object);
         std::unique_ptr<uint8_t[]> pixelData = imageBitmap->copyBitmapData(PremultiplyAlpha);
         m_writer.writeImageBitmap(imageBitmap->width(), imageBitmap->height(), pixelData.get(), imageBitmap->width() * imageBitmap->height() * 4);
     }
     return nullptr;
 }
 
 void ScriptValueSerializer::writeRegExp(v8::Local<v8::Value> value)
 {
     v8::Local<v8::RegExp> regExp = value.As<v8::RegExp>();
     m_writer.writeRegExp(regExp->GetSource(), regExp->GetFlags());
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyArrayBufferView(v8::Local<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     ASSERT(!object.IsEmpty());
     DOMArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
     if (!arrayBufferView)
         return 0;
     if (!arrayBufferView->bufferBase())
-        return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An ArrayBuffer could not be cloned.", next);
     v8::Local<v8::Value> underlyingBuffer = toV8(arrayBufferView->bufferBase(), m_scriptState->context()->Global(), isolate());
     if (underlyingBuffer.IsEmpty())
-        return handleError(DataCloneError, "An ArrayBuffer could not be cloned.", next);
+        return handleError(Status::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;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyArrayBuffer(v8::Local<v8::Object> object, ScriptValueSerializer::StateBase* next)
 {
     DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(object);
     if (!arrayBuffer)
         return nullptr;
     if (arrayBuffer->isNeutered())
-        return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
 
     uint32_t index;
     if (m_transferredArrayBuffers.tryGet(object, &index)) {
         m_writer.writeTransferredArrayBuffer(index);
     } else {
         greyObject(object);
         m_writer.writeArrayBuffer(*arrayBuffer);
     }
     return nullptr;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeTransferredOffscreenCanvas(v8::Local<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
 {
     OffscreenCanvas* offscreenCanvas = V8OffscreenCanvas::toImpl(value.As<v8::Object>());
     if (!offscreenCanvas)
         return nullptr;
     if (offscreenCanvas->isNeutered())
-        return handleError(DataCloneError, "An OffscreenCanvas is detached and could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An OffscreenCanvas is detached and could not be cloned.", next);
     if (offscreenCanvas->renderingContext())
-        return handleError(DataCloneError, "An OffscreenCanvas with a context could not be cloned.", next);
+        return handleError(Status::DataCloneError, "An OffscreenCanvas with a context could not be cloned.", next);
     m_writer.writeTransferredOffscreenCanvas(index, offscreenCanvas->width(), offscreenCanvas->height(), offscreenCanvas->getAssociatedCanvasId());
     return nullptr;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeTransferredSharedArrayBuffer(v8::Local<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
 {
     ASSERT(RuntimeEnabledFeatures::sharedArrayBufferEnabled());
     DOMSharedArrayBuffer* sharedArrayBuffer = V8SharedArrayBuffer::toImpl(value.As<v8::Object>());
     if (!sharedArrayBuffer)
         return 0;
@@ skipping 1213 matching lines @@
         return false;
     uint32_t objectReference = m_openCompositeReferenceStack[m_openCompositeReferenceStack.size() - 1];
     m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() - 1);
     if (objectReference >= m_objectPool.size())
         return false;
     *object = m_objectPool[objectReference];
     return true;
 }
 
 } // namespace blink