External references should not affect dominance relation.

src/profile-generator.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 446 matching lines @@
     kHidden = v8::HeapGraphEdge::kHidden,
     kShortcut = v8::HeapGraphEdge::kShortcut,
     kWeak = v8::HeapGraphEdge::kWeak
   };
 
   HeapGraphEdge() { }
   void Init(int child_index, Type type, const char* name, HeapEntry* to);
   void Init(int child_index, Type type, int index, HeapEntry* to);
   void Init(int child_index, int index, HeapEntry* to);
 
-  Type type() { return static_cast<Type>(type_); }
-  int index() {
+  Type type() const { return static_cast<Type>(type_); }
+  int index() const {
     ASSERT(type_ == kElement || type_ == kHidden || type_ == kWeak);
     return index_;
   }
-  const char* name() {
+  const char* name() const {
     ASSERT(type_ == kContextVariable
            || type_ == kProperty
            || type_ == kInternal
            || type_ == kShortcut);
     return name_;
   }
-  HeapEntry* to() { return to_; }
-
-  HeapEntry* From();
+  HeapEntry* to() const { return to_; }
+  INLINE(HeapEntry* from() const);
 
  private:
   int child_index_ : 29;
   unsigned type_ : 3;
   union {
     int index_;
     const char* name_;
   };
   HeapEntry* to_;
 
@@ skipping 65 matching lines @@
   Vector<HeapGraphEdge*> retainers() {
     return Vector<HeapGraphEdge*>(retainers_arr(), retainers_count_); }
   HeapEntry* dominator() { return dominator_; }
   void set_dominator(HeapEntry* entry) {
     ASSERT(entry != NULL);
     dominator_ = entry;
   }
   void clear_paint() { painted_ = false; }
   bool painted() { return painted_; }
   void paint() { painted_ = true; }
+  bool reachable_from_window() { return reachable_from_window_; }

[yurys, 2012/04/16 13:23:37]

Note, that there is no such think as Window in case of dedicated/shared web
workers. We may want a better name for the user root object.

[alexeif, 2012/04/16 13:37:23]

user_root?

+  void set_reachable_from_window() { reachable_from_window_ = true; }
 
   void SetIndexedReference(HeapGraphEdge::Type type,
                            int child_index,
                            int index,
                            HeapEntry* entry,
                            int retainer_index);
   void SetNamedReference(HeapGraphEdge::Type type,
                          int child_index,
                          const char* name,
                          HeapEntry* entry,
@@ skipping 16 matching lines @@
  private:
   HeapGraphEdge* children_arr() {
     return reinterpret_cast<HeapGraphEdge*>(this + 1);
   }
   HeapGraphEdge** retainers_arr() {
     return reinterpret_cast<HeapGraphEdge**>(children_arr() + children_count_);
   }
   const char* TypeAsString();
 
   unsigned painted_: 1;
+  unsigned reachable_from_window_: 1;
   unsigned type_: 4;
-  int children_count_: 27;
+  int children_count_: 26;
   int retainers_count_;
   int self_size_;
   union {
     int ordered_index_;  // Used during dominator tree building.
     int retained_size_;  // At that moment, there is no retained size yet.
   };
   int entry_index_;
   SnapshotObjectId id_;
   HeapEntry* dominator_;
   HeapSnapshot* snapshot_;
@@ skipping 393 matching lines @@
   void SetPropertyReference(HeapObject* parent_obj,
                             HeapEntry* parent,
                             String* reference_name,
                             Object* child,
                             const char* name_format_string = NULL,
                             int field_offset = -1);
   void SetPropertyShortcutReference(HeapObject* parent_obj,
                                     HeapEntry* parent,
                                     String* reference_name,
                                     Object* child);
-  void SetRootShortcutReference(Object* child);
+  void SetWindowReference(Object* window);
   void SetRootGcRootsReference();
   void SetGcRootsReference(VisitorSynchronization::SyncTag tag);
   void SetGcSubrootReference(
       VisitorSynchronization::SyncTag tag, bool is_weak, Object* child);
   void SetObjectName(HeapObject* object);
   void TagObject(Object* obj, const char* tag);
 
   HeapEntry* GetEntry(Object* obj);
 
   static inline HeapObject* GetNthGcSubrootObject(int delta);
@@ skipping 83 matching lines @@
   HeapSnapshotGenerator(HeapSnapshot* snapshot,
                         v8::ActivityControl* control);
   bool GenerateSnapshot();
 
  private:
   bool BuildDominatorTree(const Vector<HeapEntry*>& entries,
                           Vector<int>* dominators);
   bool CalculateRetainedSizes();
   bool CountEntriesAndReferences();
   bool FillReferences();
-  void FillReversePostorderIndexes(Vector<HeapEntry*>* entries);
+  void FillPostorderIndexes(Vector<HeapEntry*>* entries);
+  bool IsWindowReference(const HeapGraphEdge& edge);
+  void MarkWindowReachableObjects();
   void ProgressStep();
   bool ProgressReport(bool force = false);
   bool SetEntriesDominators();
   void SetProgressTotal(int iterations_count);
 
   HeapSnapshot* snapshot_;
   v8::ActivityControl* control_;
   V8HeapExplorer v8_heap_explorer_;
   NativeObjectsExplorer dom_explorer_;
   // Mapping from HeapThing pointers to HeapEntry* pointers.
@@ skipping 52 matching lines @@
 
   friend class HeapSnapshotJSONSerializerEnumerator;
   friend class HeapSnapshotJSONSerializerIterator;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshotJSONSerializer);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROFILE_GENERATOR_H_