Remove redundant IsEmpty checks after calling toV8()

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 1137 matching lines @@
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyArrayBufferView(v8::Local<v8::Object> object, StateBase* next)
 {
     ASSERT(!object.IsEmpty());
     DOMArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
     if (!arrayBufferView)
         return nullptr;
     if (!arrayBufferView->bufferBase())
         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(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;
@@ skipping 598 matching lines @@
         return false;
     ImageData* imageData = ImageData::create(IntSize(width, height));
     DOMUint8ClampedArray* pixelArray = imageData->data();
     ASSERT(pixelArray);
     ASSERT(pixelArray->length() >= pixelDataLength);
     memcpy(pixelArray->data(), m_buffer + m_position, pixelDataLength);
     m_position += pixelDataLength;
     if (!imageData)
         return false;
     *value = toV8(imageData, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readImageBitmap(v8::Local<v8::Value>* value)
 {
     uint32_t isOriginClean;
     if (!doReadUint32(&isOriginClean))
         return false;
     uint32_t isPremultiplied;
     if (!doReadUint32(&isPremultiplied))
         return false;
     uint32_t width;
     uint32_t height;
     uint32_t pixelDataLength;
     if (!doReadImageDataProperties(&width, &height, &pixelDataLength))
         return false;
     std::unique_ptr<uint8_t[]> pixelData = wrapArrayUnique(new uint8_t[pixelDataLength]);
     memcpy(pixelData.get(), m_buffer + m_position, pixelDataLength);
     m_position += pixelDataLength;
     ImageBitmap* imageBitmap = ImageBitmap::create(std::move(pixelData), width, height, isPremultiplied, isOriginClean);
     if (!imageBitmap)
         return false;
     *value = toV8(imageBitmap, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readCompositorProxy(v8::Local<v8::Value>* value)
 {
     uint32_t attributes;
     uint64_t element;
     if (!doReadUint64(&element))
         return false;
     if (!doReadUint32(&attributes))
         return false;
 
     CompositorProxy* compositorProxy = CompositorProxy::create(m_scriptState->getExecutionContext(), element, attributes);
     *value = toV8(compositorProxy, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 DOMArrayBuffer* SerializedScriptValueReader::doReadArrayBuffer()
 {
     uint32_t byteLength;
     if (!doReadUint32(&byteLength))
         return nullptr;
     if (m_position + byteLength > m_length)
         return nullptr;
     const void* bufferStart = m_buffer + m_position;
     m_position += byteLength;
     return DOMArrayBuffer::create(bufferStart, byteLength);
 }
 
 bool SerializedScriptValueReader::readArrayBuffer(v8::Local<v8::Value>* value)
 {
     DOMArrayBuffer* arrayBuffer = doReadArrayBuffer();
     if (!arrayBuffer)
         return false;
     *value = toV8(arrayBuffer, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readArrayBufferView(v8::Local<v8::Value>* value, ScriptValueDeserializer& deserializer)
 {
     ArrayBufferViewSubTag subTag;
     uint32_t byteOffset;
     uint32_t byteLength;
     DOMArrayBufferBase* arrayBuffer = nullptr;
     v8::Local<v8::Value> arrayBufferV8Value;
     if (!readArrayBufferViewSubTag(&subTag))
@@ skipping 87 matching lines @@
     case FloatArrayTag:
         *value = toV8(DOMFloat32Array::create(arrayBuffer, byteOffset, numElements), creationContext, isolate());
         break;
     case DoubleArrayTag:
         *value = toV8(DOMFloat64Array::create(arrayBuffer, byteOffset, numElements), creationContext, isolate());
         break;
     case DataViewTag:
         *value = toV8(DOMDataView::create(arrayBuffer, byteOffset, byteLength), creationContext, isolate());
         break;
     }
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readRegExp(v8::Local<v8::Value>* value)
 {
     v8::Local<v8::Value> pattern;
     if (!readString(&pattern))
         return false;
     uint32_t flags;
     if (!doReadUint32(&flags))
         return false;
@@ skipping 24 matching lines @@
         ASSERT(!m_blobInfo);
         if (!readWebCoreString(&uuid))
             return false;
         if (!readWebCoreString(&type))
             return false;
         if (!doReadUint64(&size))
             return false;
         blob = Blob::create(getOrCreateBlobDataHandle(uuid, type, size));
     }
     *value = toV8(blob, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readFile(v8::Local<v8::Value>* value, bool isIndexed)
 {
     File* file = nullptr;
     if (isIndexed) {
         if (m_version < 6)
             return false;
         file = readFileIndexHelper();
     } else {
         file = readFileHelper();
     }
     if (!file)
         return false;
     *value = toV8(file, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 bool SerializedScriptValueReader::readFileList(v8::Local<v8::Value>* value, bool isIndexed)
 {
     if (m_version < 3)
         return false;
     uint32_t length;
     if (!doReadUint32(&length))
         return false;
     FileList* fileList = FileList::create();
     for (unsigned i = 0; i < length; ++i) {
         File* file = nullptr;
         if (isIndexed) {
             if (m_version < 6)
                 return false;
             file = readFileIndexHelper();
         } else {
             file = readFileHelper();
         }
         if (!file)
             return false;
         fileList->append(file);
     }
     *value = toV8(fileList, m_scriptState->context()->Global(), isolate());
-    return !value->IsEmpty();
+    return true;
 }
 
 File* SerializedScriptValueReader::readFileHelper()
 {
     if (m_version < 3)
         return nullptr;
     ASSERT(!m_blobInfo);
     String path;
     String name;
     String relativePath;
@@ skipping 253 matching lines @@
 }
 
 bool ScriptValueDeserializer::tryGetTransferredMessagePort(uint32_t index, v8::Local<v8::Value>* object)
 {
     if (!m_transferredMessagePorts)
         return false;
     if (index >= m_transferredMessagePorts->size())
         return false;
     v8::Local<v8::Object> creationContext = m_reader.getScriptState()->context()->Global();
     *object = toV8(m_transferredMessagePorts->at(index).get(), creationContext, m_reader.getScriptState()->isolate());
-    return !object->IsEmpty();
+    return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredArrayBuffer(uint32_t index, v8::Local<v8::Value>* object)
 {
     if (!m_arrayBufferContents)
         return false;
     if (index >= m_arrayBuffers.size())
         return false;
     v8::Local<v8::Value> result = m_arrayBuffers.at(index);
     if (result.IsEmpty()) {
         DOMArrayBuffer* buffer = DOMArrayBuffer::create(m_arrayBufferContents->at(index));
         v8::Isolate* isolate = m_reader.getScriptState()->isolate();
         v8::Local<v8::Object> creationContext = m_reader.getScriptState()->context()->Global();
         result = toV8(buffer, creationContext, isolate);
-        if (result.IsEmpty())
-            return false;
         m_arrayBuffers[index] = result;
     }
     *object = result;
     return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredImageBitmap(uint32_t index, v8::Local<v8::Value>* object)
 {
     if (!m_imageBitmapContents)
         return false;
     if (index >= m_imageBitmaps.size())
         return false;
     v8::Local<v8::Value> result = m_imageBitmaps.at(index);
     if (result.IsEmpty()) {
         ImageBitmap* bitmap = ImageBitmap::create(m_imageBitmapContents->at(index));
         v8::Isolate* isolate = m_reader.getScriptState()->isolate();
         v8::Local<v8::Object> creationContext = m_reader.getScriptState()->context()->Global();
         result = toV8(bitmap, creationContext, isolate);
-        if (result.IsEmpty())
-            return false;
         m_imageBitmaps[index] = result;
     }
     *object = result;
     return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredSharedArrayBuffer(uint32_t index, v8::Local<v8::Value>* object)
 {
     ASSERT(RuntimeEnabledFeatures::sharedArrayBufferEnabled());
     if (!m_arrayBufferContents)
         return false;
     if (index >= m_arrayBuffers.size())
         return false;
     v8::Local<v8::Value> result = m_arrayBuffers.at(index);
     if (result.IsEmpty()) {
         DOMSharedArrayBuffer* buffer = DOMSharedArrayBuffer::create(m_arrayBufferContents->at(index));
         v8::Isolate* isolate = m_reader.getScriptState()->isolate();
         v8::Local<v8::Object> creationContext = m_reader.getScriptState()->context()->Global();
         result = toV8(buffer, creationContext, isolate);
-        if (result.IsEmpty())
-            return false;
         m_arrayBuffers[index] = result;
     }
     *object = result;
     return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredOffscreenCanvas(uint32_t index, uint32_t width, uint32_t height, uint32_t canvasId, uint32_t clientId, uint32_t localId, uint64_t nonce, v8::Local<v8::Value>* object)
 {
     OffscreenCanvas* offscreenCanvas = OffscreenCanvas::create(width, height);
     offscreenCanvas->setAssociatedCanvasId(canvasId);
     offscreenCanvas->setSurfaceId(clientId, localId, nonce);
     *object = toV8(offscreenCanvas, m_reader.getScriptState());
-    if ((*object).IsEmpty())
-        return false;
     return true;
 }
 
 bool ScriptValueDeserializer::tryGetObjectFromObjectReference(uint32_t reference, v8::Local<v8::Value>* object)
 {
     if (reference >= m_objectPool.size())
         return false;
     *object = m_objectPool[reference];
     return object;
 }
@@ skipping 61 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