reflow comments in Source/bindings/core/v8

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

 // 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.
 
 #ifndef ScriptValueSerializer_h
 #define ScriptValueSerializer_h
 
 #include "base/gtest_prod_util.h"
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
@@ skipping 14 matching lines @@
 class DOMSharedArrayBuffer;
 class File;
 class FileList;
 class ImageData;
 class StaticBitmapImage;
 
 typedef Vector<WTF::ArrayBufferContents, 1> ArrayBufferContentsArray;
 typedef Vector<RefPtr<StaticBitmapImage>, 1> ImageBitmapContentsArray;
 
 // V8ObjectMap is a map from V8 objects to arbitrary values of type T.
-// V8 objects (or handles to V8 objects) cannot be used as keys in ordinary wtf::HashMaps;
-// this class should be used instead. GCObject must be a subtype of v8::Object.
+// V8 objects (or handles to V8 objects) cannot be used as keys in ordinary
+// wtf::HashMaps; this class should be used instead. GCObject must be a subtype
+// of v8::Object.
 // Suggested usage:
 //     V8ObjectMap<v8::Object, int> map;
 //     v8::Local<v8::Object> obj = ...;
 //     map.set(obj, 42);
 template <typename GCObject, typename T>
 class V8ObjectMap {
   STACK_ALLOCATED();
 
  public:
   bool contains(const v8::Local<GCObject>& handle) {
     return m_map.contains(*handle);
   }
 
   bool tryGet(const v8::Local<GCObject>& handle, T* valueOut) {
     typename HandleToT::iterator result = m_map.find(*handle);
     if (result != m_map.end()) {
       *valueOut = result->value;
       return true;
     }
     return false;
   }
 
   void set(const v8::Local<GCObject>& handle, const T& value) {
     m_map.set(*handle, value);
   }
 
  private:
-  // This implementation uses GetIdentityHash(), which sets a hidden property on the object containing
-  // a random integer (or returns the one that had been previously set). This ensures that the table
-  // never needs to be rebuilt across garbage collections at the expense of doing additional allocation
-  // and making more round trips into V8. Note that since GetIdentityHash() is defined only on
-  // v8::Objects, this V8ObjectMap cannot be used to map v8::Strings to T (because the public V8 API
-  // considers a v8::String to be a v8::Primitive).
+  // This implementation uses GetIdentityHash(), which sets a hidden property on
+  // the object containing a random integer (or returns the one that had been
+  // previously set). This ensures that the table never needs to be rebuilt
+  // across garbage collections at the expense of doing additional allocation
+  // and making more round trips into V8. Note that since GetIdentityHash() is
+  // defined only on v8::Objects, this V8ObjectMap cannot be used to map
+  // v8::Strings to T (because the public V8 API considers a v8::String to be a
+  // v8::Primitive).
 
-  // If V8 exposes a way to get at the address of the object held by a handle, then we can produce
-  // an alternate implementation that does not need to do any V8-side allocation; however, it will
-  // need to rehash after every garbage collection because a key object may have been moved.
+  // If V8 exposes a way to get at the address of the object held by a handle,
+  // then we can produce an alternate implementation that does not need to do
+  // any V8-side allocation; however, it will need to rehash after every garbage
+  // collection because a key object may have been moved.
   template <typename G>
   struct V8HandlePtrHash {
     STATIC_ONLY(V8HandlePtrHash);
     static v8::Local<G> unsafeHandleFromRawValue(const G* value) {
       const v8::Local<G>* handle =
           reinterpret_cast<const v8::Local<G>*>(&value);
       return *handle;
     }
 
     static unsigned hash(const G* key) {
       return static_cast<unsigned>(
           unsafeHandleFromRawValue(key)->GetIdentityHash());
     }
     static bool equal(const G* a, const G* b) {
       return unsafeHandleFromRawValue(a) == unsafeHandleFromRawValue(b);
     }
     // For HashArg.
     static const bool safeToCompareToEmptyOrDeleted = false;
   };
 
   typedef WTF::HashMap<GCObject*, T, V8HandlePtrHash<GCObject>> HandleToT;
   HandleToT m_map;
 };
 
-// SerializedScriptValueWriter is responsible for serializing primitive types and storing
-// information used to reconstruct composite types.
+// SerializedScriptValueWriter is responsible for serializing primitive types
+// and storing information used to reconstruct composite types.
 class CORE_EXPORT SerializedScriptValueWriter {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(SerializedScriptValueWriter);
 
  public:
   typedef UChar BufferValueType;
 
   SerializedScriptValueWriter() : m_position(0) {}
 
  protected:
@@ skipping 260 matching lines @@
     v8::Local<v8::Array> m_entries;
     uint32_t m_index;
     uint32_t m_length;
   };
 
   typedef CollectionState<v8::Map> MapState;
   typedef CollectionState<v8::Set> SetState;
 
   virtual StateBase* doSerializeObject(v8::Local<v8::Object>, StateBase* 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 greyObject(const v8::Local<v8::Object>&);
 
   StateBase* handleError(Status errorStatus, const String& message, StateBase*);
 
   SerializedScriptValueWriter& writer() { return m_writer; }
 
  private:
   StateBase* doSerialize(v8::Local<v8::Value>, StateBase* next);
   StateBase* doSerializeArrayBuffer(v8::Local<v8::Value> arrayBuffer,
                                     StateBase* next);
@@ skipping 82 matching lines @@
   BlobDataHandleMap* m_blobDataHandles;
 
   // Counts of object types encountered while serializing the object graph.
   int m_primitiveCount = 0;
   int m_jsObjectCount = 0;
   int m_domWrapperCount = 0;
 };
 
 class ScriptValueDeserializer;
 
-// SerializedScriptValueReader is responsible for deserializing primitive types and
-// restoring information about saved objects of composite types.
+// SerializedScriptValueReader is responsible for deserializing primitive types
+// and restoring information about saved objects of composite types.
 class CORE_EXPORT SerializedScriptValueReader {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(SerializedScriptValueReader);
 
  public:
   SerializedScriptValueReader(const uint8_t* buffer,
                               int length,
                               const WebBlobInfoArray* blobInfo,
                               BlobDataHandleMap& blobDataHandles,
                               ScriptState* scriptState)
@@ skipping 176 matching lines @@
   ArrayBufferContentsArray* m_arrayBufferContents;
   ImageBitmapContentsArray* m_imageBitmapContents;
   Vector<v8::Local<v8::Value>> m_arrayBuffers;
   Vector<v8::Local<v8::Value>> m_imageBitmaps;
   uint32_t m_version;
 };
 
 }  // namespace blink
 
 #endif  // ScriptValueSerializer_h