reflow comments in Source/bindings/core/v8

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 58 matching lines @@
 const int maxDepth = 20000;
 
 bool shouldCheckForCycles(int depth) {
   ASSERT(depth >= 0);
   // Since we are not required to spot the cycle as soon as it
   // happens we can check for cycles only when the current depth
   // is a power of two.
   return !(depth & (depth - 1));
 }
 
-// Returns true if the provided object is to be considered a 'host object', as used in the
-// HTML5 structured clone algorithm.
+// Returns true if the provided object is to be considered a 'host object', as
+// used in the HTML5 structured clone algorithm.
 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.
+  // 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();
 }
 
 }  // namespace
 
 void SerializedScriptValueWriter::writeUndefined() {
   append(UndefinedTag);
 }
 
 void SerializedScriptValueWriter::writeNull() {
@@ skipping 472 matching lines @@
       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.
+    // |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(
           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 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);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::ObjectState::advance(
     ScriptValueSerializer& serializer) {
   if (m_propertyNames.IsEmpty()) {
     if (!composite()
@@ skipping 361 matching lines @@
     return nullptr;
   }
   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.
+  // Since IsNativeError is expensive, this check should always be the last
+  // check.
   if (isHostObject(object) || object->IsCallable() || object->IsNativeError()) {
     return handleError(Status::DataCloneError, "An object could not be cloned.",
                        next);
   }
 
   return startObjectState(object, next);
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::doSerializeArrayBuffer(
     v8::Local<v8::Value> arrayBuffer,
@@ skipping 241 matching lines @@
   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.
+  // 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).
+  // (or without an additional tag that would allow us to do two-stage
+  // construction like we do for Objects and Arrays).
   greyObject(object);
   return nullptr;
 }
 
 ScriptValueSerializer::StateBase*
 ScriptValueSerializer::writeWasmCompiledModule(v8::Local<v8::Object> object,
                                                StateBase* next) {
   CHECK(RuntimeEnabledFeatures::webAssemblySerializationEnabled());
   // TODO (mtrofin): explore mechanism avoiding data copying / buffer resizing.
   v8::Local<v8::WasmCompiledModule> wasmModule =
@@ skipping 59 matching lines @@
       V8SharedArrayBuffer::toImpl(value.As<v8::Object>());
   if (!sharedArrayBuffer)
     return 0;
   m_writer.writeTransferredSharedArrayBuffer(index);
   return nullptr;
 }
 
 bool ScriptValueSerializer::shouldSerializeDensely(uint32_t length,
                                                    uint32_t propertyCount) {
   // Let K be the cost of serializing all property values that are there
-  // Cost of serializing sparsely: 5*propertyCount + K (5 bytes per uint32_t key)
-  // Cost of serializing densely: K + 1*(length - propertyCount) (1 byte for all properties that are not there)
+  // Cost of serializing sparsely: 5*propertyCount + K (5 bytes per uint32_t
+  // key)
+  // Cost of serializing densely: K + 1*(length - propertyCount) (1 byte for all
+  // properties that are not there)
   // so densely is better than sparsly whenever 6*propertyCount > length
   return 6 * propertyCount >= length;
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::startArrayState(
     v8::Local<v8::Array> array,
     StateBase* next) {
   v8::Local<v8::Array> propertyNames;
   if (!array->GetOwnPropertyNames(context()).ToLocal(&propertyNames))
     return checkException(next);
@@ skipping 34 matching lines @@
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializer::startObjectState(
     v8::Local<v8::Object> object,
     StateBase* next) {
   m_writer.writeGenerateFreshObject();
   // FIXME: check not a wrapper
   return push(new ObjectState(object, next));
 }
 
-// Marks object as having been visited by the serializer and assigns it a unique object reference ID.
-// An object may only be greyed once.
+// Marks object as having been visited by the serializer and assigns it a unique
+// object reference ID.  An object may only be greyed once.
 void ScriptValueSerializer::greyObject(const v8::Local<v8::Object>& object) {
   ASSERT(!m_objectPool.contains(object));
   uint32_t objectReference = m_nextObjectReference++;
   m_objectPool.set(object, objectReference);
 }
 
 bool ScriptValueSerializer::appendBlobInfo(const String& uuid,
                                            const String& type,
                                            unsigned long long size,
                                            int* index) {
@@ skipping 31 matching lines @@
     SerializationTag tag,
     v8::Local<v8::Value>* value,
     ScriptValueDeserializer& deserializer) {
   switch (tag) {
     case ReferenceCountTag: {
       if (!m_version)
         return false;
       uint32_t referenceTableSize;
       if (!doReadUint32(&referenceTableSize))
         return false;
-      // If this test fails, then the serializer and deserializer disagree about the assignment
-      // of object reference IDs. On the deserialization side, this means there are too many or too few
-      // calls to pushObjectReference.
+      // If this test fails, then the serializer and deserializer disagree about
+      // the assignment of object reference IDs. On the deserialization side,
+      // this means there are too many or too few calls to pushObjectReference.
       if (referenceTableSize != deserializer.objectReferenceCount())
         return false;
       return true;
     }
     case InvalidTag:
       return false;
     case PaddingTag:
       return true;
     case UndefinedTag:
       *value = v8::Undefined(isolate());
@@ skipping 813 matching lines @@
   for (unsigned i = 0; i < sizeof(double); ++i)
     numberAsByteArray[i] = m_buffer[m_position++];
   return true;
 }
 
 PassRefPtr<BlobDataHandle>
 SerializedScriptValueReader::getOrCreateBlobDataHandle(const String& uuid,
                                                        const String& type,
                                                        long long size) {
   // The containing ssv may have a BDH for this uuid if this ssv is just being
-  // passed from main to worker thread (for example). We use those values when creating
-  // the new blob instead of cons'ing up a new BDH.
+  // passed from main to worker thread (for example). We use those values when
+  // creating the new blob instead of cons'ing up a new BDH.
   //
-  // FIXME: Maybe we should require that it work that way where the ssv must have a BDH for any
-  // blobs it comes across during deserialization. Would require callers to explicitly populate
-  // the collection of BDH's for blobs to work, which would encourage lifetimes to be considered
-  // when passing ssv's around cross process. At present, we get 'lucky' in some cases because
-  // the blob in the src process happens to still exist at the time the dest process is deserializing.
+  // FIXME: Maybe we should require that it work that way where the ssv must
+  // have a BDH for any blobs it comes across during deserialization. Would
+  // require callers to explicitly populate the collection of BDH's for blobs to
+  // work, which would encourage lifetimes to be considered when passing ssv's
+  // around cross process. At present, we get 'lucky' in some cases because the
+  // blob in the src process happens to still exist at the time the dest process
+  // is deserializing.
   // For example in sharedWorker.postMessage(...).
   BlobDataHandleMap::const_iterator it = m_blobDataHandles.find(uuid);
   if (it != m_blobDataHandles.end()) {
     // make assertions about type and size?
     return it->value;
   }
   return BlobDataHandle::create(uuid, type, size);
 }
 
 v8::Local<v8::Value> ScriptValueDeserializer::deserialize() {
@@ skipping 337 matching lines @@
       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