Fixes for comments in http://codereview.chromium.org/113641.

test/cctest/test-log.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 //
 // Tests of logging functions from log.h
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #include "v8.h"
 
 #include "log.h"
 #include "cctest.h"
@@ skipping 245 matching lines @@
 namespace {
 
 // A code entity is a pointer to a position of code-creation event in buffer log
 // offset to a point where entity size begins, i.e.: '255,"func"\n'. This makes
 // comparing code entities pretty easy.
 typedef char* CodeEntityInfo;
 
 class Interval {
  public:
   Interval()
-      : min_addr(reinterpret_cast<Address>(-1)),
-        max_addr(reinterpret_cast<Address>(0)), next(NULL) {}
+      : min_addr_(reinterpret_cast<Address>(-1)),
+        max_addr_(reinterpret_cast<Address>(0)), next_(NULL) {}
 
-  ~Interval() { delete next; }
+  ~Interval() { delete next_; }
 
   size_t Length() {
-    size_t result = max_addr - min_addr + 1;
-    if (next != NULL) result += next->Length();
+    size_t result = max_addr_ - min_addr_ + 1;
+    if (next_ != NULL) result += next_->Length();
     return result;
   }
 
   void CloneFrom(Interval* src) {
     while (src != NULL) {
-      RegisterAddress(src->min_addr);
-      RegisterAddress(src->max_addr);
-      src = src->next;
+      RegisterAddress(src->min_addr_);
+      RegisterAddress(src->max_addr_);
+      src = src->next_;
     }
   }
 
   bool Contains(Address addr) {
-    if (min_addr <= addr && addr <= max_addr) {
+    if (min_addr_ <= addr && addr <= max_addr_) {
       return true;
     }
-    if (next != NULL) return next->Contains(addr);
-    return false;
+    if (next_ != NULL) {
+      return next_->Contains(addr);
+    } else {
+      return false;
+    }
   }
 
   size_t GetIndex(Address addr) {
-    if (min_addr <= addr && addr <= max_addr) {
-      return addr - min_addr;
+    if (min_addr_ <= addr && addr <= max_addr_) {
+      return addr - min_addr_;
     }
-    CHECK_NE(NULL, next);
-    return (max_addr - min_addr + 1) + next->GetIndex(addr);
+    CHECK_NE(NULL, next_);
+    return (max_addr_ - min_addr_ + 1) + next_->GetIndex(addr);
   }
 
   Address GetMinAddr() {
-    return next == NULL ? min_addr : i::Min(min_addr, next->GetMinAddr());
+    return next_ == NULL ? min_addr_ : i::Min(min_addr_, next_->GetMinAddr());
   }
 
   Address GetMaxAddr() {
-    return next == NULL ? max_addr : i::Max(max_addr, next->GetMaxAddr());
+    return next_ == NULL ? max_addr_ : i::Max(max_addr_, next_->GetMaxAddr());
   }
 
   void RegisterAddress(Address addr) {
-    if (min_addr == reinterpret_cast<Address>(-1)
-        || (size_t)(addr > min_addr ?
-           addr - min_addr : min_addr - addr) < MAX_DELTA) {
-      if (addr < min_addr) min_addr = addr;
-      if (addr > max_addr) max_addr = addr;
+    if (min_addr_ == reinterpret_cast<Address>(-1)
+        || (size_t)(addr > min_addr_ ?
+           addr - min_addr_ : min_addr_ - addr) < MAX_DELTA) {
+      if (addr < min_addr_) min_addr_ = addr;
+      if (addr > max_addr_) max_addr_ = addr;
     } else {
-      if (next == NULL) next = new Interval();
-      next->RegisterAddress(addr);
+      if (next_ == NULL) next_ = new Interval();
+      next_->RegisterAddress(addr);
     }
   }
 
-  Address raw_min_addr() { return min_addr; }
+  Address raw_min_addr() { return min_addr_; }
 
-  Address raw_max_addr() { return max_addr; }
+  Address raw_max_addr() { return max_addr_; }
 
-  Interval* get_next() { return next; }
+  Interval* get_next() { return next_; }
 
  private:
   static const size_t MAX_DELTA = 0x100000;
-  Address min_addr;
-  Address max_addr;
-  Interval* next;
+  Address min_addr_;
+  Address max_addr_;
+  Interval* next_;
 };
 
 
 // A structure used to return log parsing results.
 class ParseLogResult {
  public:
   ParseLogResult()
       : entities_map(NULL), entities(NULL),
         max_entities(0) {}
 
@@ skipping 46 matching lines @@
   Address ConsumeAddress(char** start) {
     char* end_ptr;
     Address addr =
         reinterpret_cast<Address>(strtoul(*start, &end_ptr, 16));  // NOLINT
     CHECK(HasIndexForAddress(addr));
     *start = end_ptr;
     return addr;
   }
 
   Interval bounds;
-  // Memory map of entities start addresses. Biased by bounds.min_addr.
+  // Memory map of entities start addresses.
   int* entities_map;
   // An array of code entities.
   CodeEntityInfo* entities;
   // Maximal entities count. Actual entities count can be lower,
   // empty entity slots are pointing to NULL.
   int max_entities;
 };
 
 }  // namespace
 
@@ skipping 287 matching lines @@
   fflush(stdout);
   CHECK(results_equal);
 
   env->Exit();
   Logger::TearDown();
   i::FLAG_always_compact = saved_always_compact;
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING