Fix variables names.

src/heap-profiler.cc

 // Copyright 2009 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 51 matching lines @@
 }
 
 
 // A helper class for recording back references.
 class ReferencesExtractor : public ObjectVisitor {
  public:
   ReferencesExtractor(
       const JSObjectsCluster& cluster, RetainerHeapProfile* profile)
       : cluster_(cluster),
         profile_(profile),
-        insideArray_(false) {
+        inside_array_(false) {
   }
 
   void VisitPointer(Object** o) {
     if ((*o)->IsJSObject() || (*o)->IsString()) {
       profile_->StoreReference(cluster_, *o);
-    } else if ((*o)->IsFixedArray() && !insideArray_) {
+    } else if ((*o)->IsFixedArray() && !inside_array_) {
       // Traverse one level deep for data members that are fixed arrays.
       // This covers the case of 'elements' and 'properties' of JSObject,
       // and function contexts.
-      insideArray_ = true;
+      inside_array_ = true;
       FixedArray::cast(*o)->Iterate(this);
-      insideArray_ = false;
+      inside_array_ = false;
     }
   }
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) VisitPointer(p);
   }
 
  private:
   const JSObjectsCluster& cluster_;
   RetainerHeapProfile* profile_;
-  bool insideArray_;
+  bool inside_array_;
 };
 
 
 // A printer interface implementation for the Retainers profile.
 class RetainersPrinter : public RetainerHeapProfile::Printer {
  public:
   void PrintRetainers(const StringStream& retainers) {
     LOG(HeapSampleJSRetainersEvent(*(retainers.ToCString())));
   }
 };
@@ skipping 113 matching lines @@
   for (int i = 0; i < a.refs.length(); ++i) {
     int cmp = JSObjectsCluster::Compare(a.refs[i], b.refs[i]);
     if (cmp != 0) return cmp;
   }
   return 0;
 }
 
 
 ClustersCoarser::ClustersCoarser()
   : zscope_(DELETE_ON_EXIT),
-    simList_(ClustersCoarser::kInitialSimilarityListCapacity),
-    currentPair_(NULL) {
+    sim_list_(ClustersCoarser::kInitialSimilarityListCapacity),
+    current_pair_(NULL) {
 }
 
 
 void ClustersCoarser::Call(
     const JSObjectsCluster& cluster, JSObjectsClusterTree* tree) {
   if (tree != NULL) {
     // First level of retainer graph.
     if (!cluster.can_be_coarsed()) return;
     ClusterBackRefs pair(cluster);
-    ASSERT(currentPair_ == NULL);
-    currentPair_ = &pair;
-    currentSet_ = new JSObjectsClusterTree();
+    ASSERT(current_pair_ == NULL);
+    current_pair_ = &pair;
+    current_set_ = new JSObjectsClusterTree();
     tree->ForEach(this);
-    simList_.Add(pair);
-    currentPair_ = NULL;
-    currentSet_ = NULL;
+    sim_list_.Add(pair);
+    current_pair_ = NULL;
+    current_set_ = NULL;
   } else {
     // Second level of retainer graph.
-    ASSERT(currentPair_ != NULL);
-    ASSERT(currentSet_ != NULL);
+    ASSERT(current_pair_ != NULL);
+    ASSERT(current_set_ != NULL);
     JSObjectsCluster eq = GetCoarseEquivalent(cluster);
     JSObjectsClusterTree::Locator loc;
     if (!eq.is_null()) {
-      if (currentSet_->Find(eq, &loc)) return;
-      currentPair_->refs.Add(eq);
-      currentSet_->Insert(eq, &loc);
+      if (current_set_->Find(eq, &loc)) return;
+      current_pair_->refs.Add(eq);
+      current_set_->Insert(eq, &loc);
     } else {
-      currentPair_->refs.Add(cluster);
+      current_pair_->refs.Add(cluster);
     }
   }
 }
 
 
 void ClustersCoarser::Process(JSObjectsClusterTree* tree) {
   int last_eq_clusters = -1;
   for (int i = 0; i < kMaxPassesCount; ++i) {
-    simList_.Clear();
+    sim_list_.Clear();
     const int curr_eq_clusters = DoProcess(tree);
     // If no new cluster equivalents discovered, abort processing.
     if (last_eq_clusters == curr_eq_clusters) break;
     last_eq_clusters = curr_eq_clusters;
   }
 }
 
 
 int ClustersCoarser::DoProcess(JSObjectsClusterTree* tree) {
   tree->ForEach(this);
   // To sort similarity list properly, references list of a cluster is
   // required to be sorted, thus 'O1 <- A, B' and 'O2 <- B, A' would
   // be considered equivalent. But we don't sort them explicitly
   // because we know that they come from a splay tree traversal, so
   // they are already sorted.
-  simList_.Sort(ClusterBackRefsCmp);
+  sim_list_.Sort(ClusterBackRefsCmp);
   return FillEqualityTree();
 }
 
 
 JSObjectsCluster ClustersCoarser::GetCoarseEquivalent(
     const JSObjectsCluster& cluster) {
   if (!cluster.can_be_coarsed()) return JSObjectsCluster();
   EqualityTree::Locator loc;
-  return eqTree_.Find(cluster, &loc) ? loc.value() : JSObjectsCluster();
+  return eq_tree_.Find(cluster, &loc) ? loc.value() : JSObjectsCluster();
 }
 
 
 bool ClustersCoarser::HasAnEquivalent(const JSObjectsCluster& cluster) {
   // Return true for coarsible clusters that have a non-identical equivalent.
   return cluster.can_be_coarsed() &&
       JSObjectsCluster::Compare(cluster, GetCoarseEquivalent(cluster)) != 0;
 }
 
 
 int ClustersCoarser::FillEqualityTree() {
-  int eqClustersCount = 0;
-  int eqTo = 0;
-  bool firstAdded = false;
-  for (int i = 1; i < simList_.length(); ++i) {
-    if (ClusterBackRefs::Compare(simList_[i], simList_[eqTo]) == 0) {
+  int eq_clusters_count = 0;
+  int eq_to = 0;
+  bool first_added = false;
+  for (int i = 1; i < sim_list_.length(); ++i) {
+    if (ClusterBackRefs::Compare(sim_list_[i], sim_list_[eq_to]) == 0) {
       EqualityTree::Locator loc;
-      if (!firstAdded) {
+      if (!first_added) {
         // Add self-equivalence, if we have more than one item in this
         // equivalence class.
-        eqTree_.Insert(simList_[eqTo].cluster, &loc);
-        loc.set_value(simList_[eqTo].cluster);
-        firstAdded = true;
+        eq_tree_.Insert(sim_list_[eq_to].cluster, &loc);
+        loc.set_value(sim_list_[eq_to].cluster);
+        first_added = true;
       }
-      eqTree_.Insert(simList_[i].cluster, &loc);
-      loc.set_value(simList_[eqTo].cluster);
-      ++eqClustersCount;
+      eq_tree_.Insert(sim_list_[i].cluster, &loc);
+      loc.set_value(sim_list_[eq_to].cluster);
+      ++eq_clusters_count;
     } else {
-      eqTo = i;
-      firstAdded = false;
+      eq_to = i;
+      first_added = false;
     }
   }
-  return eqClustersCount;
+  return eq_clusters_count;
 }
 
 
 const JSObjectsCluster ClustersCoarser::ClusterEqualityConfig::kNoKey;
 const JSObjectsCluster ClustersCoarser::ClusterEqualityConfig::kNoValue;
 const JSObjectsClusterTreeConfig::Key JSObjectsClusterTreeConfig::kNoKey;
 const JSObjectsClusterTreeConfig::Value JSObjectsClusterTreeConfig::kNoValue =
     NULL;
 
 
@@ skipping 30 matching lines @@
 
 
 void RetainerHeapProfile::StoreReference(
     const JSObjectsCluster& cluster,
     Object* ref) {
   JSObjectsCluster ref_cluster = Clusterize(ref);
   JSObjectsClusterTree::Locator ref_loc;
   if (retainers_tree_.Insert(ref_cluster, &ref_loc)) {
     ref_loc.set_value(new JSObjectsClusterTree());
   }
-  JSObjectsClusterTree* referencedBy = ref_loc.value();
+  JSObjectsClusterTree* referenced_by = ref_loc.value();
   JSObjectsClusterTree::Locator obj_loc;
-  referencedBy->Insert(cluster, &obj_loc);
+  referenced_by->Insert(cluster, &obj_loc);
 }
 
 
 void RetainerHeapProfile::CollectStats(HeapObject* obj) {
   if (obj->IsJSObject()) {
     const JSObjectsCluster cluster = Clusterize(JSObject::cast(obj));
     ReferencesExtractor extractor(cluster, this);
     obj->Iterate(&extractor);
   } else if (obj->IsJSGlobalPropertyCell()) {
     JSObjectsCluster global_prop(JSObjectsCluster::GLOBAL_PROPERTY);
@@ skipping 121 matching lines @@
   js_retainer_profile.PrintStats();
 
   LOG(HeapSampleEndEvent("Heap", "allocated"));
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 } }  // namespace v8::internal