Cosmetic changes ("set up" is a verb, "setup" is a noun).

src/liveobjectlist.h

 // Copyright 2011 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 59 matching lines @@
 // and inspect its longevity while debugging JS code in execution.
 //
 // The lol comes with utility functions to capture, dump, summarize, and diff
 // captured lols amongst other functionality.  These functionality are
 // accessible via the v8 debugger interface.
 class LiveObjectList {
  public:
   inline static void GCEpilogue();
   inline static void GCPrologue();
   inline static void IterateElements(ObjectVisitor* v);
-  inline static void ProcessNonLive(HeapObject *obj);
+  inline static void ProcessNonLive(HeapObject* obj);
   inline static void UpdateReferencesForScavengeGC();
 
   // Note: LOLs can be listed by calling Dump(0, <lol id>), and 2 LOLs can be
   // compared/diff'ed using Dump(<lol id1>, <lol id2>, ...).  This will yield
   // a verbose dump of all the objects in the resultant lists.
   //   Similarly, a summarized result of a LOL listing or a diff can be
   // attained using the Summarize(0, <lol id>) and Summarize(<lol id1,
   // <lol id2>, ...) respectively.
 
   static MaybeObject* Capture();
@@ skipping 27 matching lines @@
     int id_;
     HeapObject* obj_;
   };
 
   explicit LiveObjectList(LiveObjectList* prev, int capacity);
   ~LiveObjectList();
 
   static void GCEpiloguePrivate();
   static void IterateElementsPrivate(ObjectVisitor* v);
 
-  static void DoProcessNonLive(HeapObject *obj);
+  static void DoProcessNonLive(HeapObject* obj);
 
   static int CompareElement(const Element* a, const Element* b);
 
   static Object* GetPathPrivate(HeapObject* obj1, HeapObject* obj2);
 
   static int GetRetainers(Handle<HeapObject> target,
                           Handle<JSObject> instance_filter,
                           Handle<FixedArray> retainers_arr,
                           int start,
                           int dump_limit,
                           int* total_count,
                           LolFilter* filter,
-                          LiveObjectSummary *summary,
+                          LiveObjectSummary* summary,
                           JSFunction* arguments_function,
                           Handle<Object> error);
 
   static MaybeObject* DumpPrivate(DumpWriter* writer,
                                   int start,
                                   int dump_limit,
                                   LolFilter* filter);
   static MaybeObject* SummarizePrivate(SummaryWriter* writer,
                                        LolFilter* filter,
                                        bool is_tracking_roots);
 
   static bool NeedLOLProcessing() { return (last() != NULL); }
-  static void NullifyNonLivePointer(HeapObject **p) {
+  static void NullifyNonLivePointer(HeapObject** p) {
     // Mask out the low bit that marks this as a heap object.  We'll use this
     // cleared bit as an indicator that this pointer needs to be collected.
     //
     // Meanwhile, we still preserve its approximate value so that we don't
     // have to resort the elements list all the time.
     //
     // Note: Doing so also makes this HeapObject* look like an SMI.  Hence,
     // GC pointer updater will ignore it when it gets scanned.
     *p = reinterpret_cast<HeapObject*>((*p)->address());
   }
@@ skipping 30 matching lines @@
 
   inline static int GetElementId(Element* element);
   inline static HeapObject* GetElementObj(Element* element);
 
   // Instance fields.
   LiveObjectList* prev_;
   LiveObjectList* next_;
   int id_;
   int capacity_;
   int obj_count_;
-  Element *elements_;
+  Element* elements_;
 
   // Statics for managing all the lists.
   static uint32_t next_element_id_;
   static int list_count_;
   static int last_id_;
   static LiveObjectList* first_;
   static LiveObjectList* last_;
 
   friend class LolIterator;
   friend class LolForwardIterator;
@@ skipping 94 matching lines @@
   }
   inline static Object* PrintObj(int obj_id) { return HEAP->undefined_value(); }
 };
 
 
 #endif  // LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #endif  // V8_LIVEOBJECTLIST_H_