Free PerThreadAssertData when possible to avoid memory leak.

src/assert-scope.h

 // Copyright 2013 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 30 matching lines @@
   HANDLE_ALLOCATION_ASSERT,
   HANDLE_DEREFERENCE_ASSERT,
   DEFERRED_HANDLE_DEREFERENCE_ASSERT,
   LAST_PER_THREAD_ASSERT_TYPE
 };
 
 
 #ifdef DEBUG
 class PerThreadAssertData {
  public:
-  PerThreadAssertData() {
+  PerThreadAssertData() : nesting_level_(0) {
     for (int i = 0; i < LAST_PER_THREAD_ASSERT_TYPE; i++) {
       assert_states_[i] = true;
     }
   }
 
   void set(PerThreadAssertType type, bool allow) {
     assert_states_[type] = allow;
   }
 
   bool get(PerThreadAssertType type) const {
     return assert_states_[type];
   }
 
+  void increment_level() { ++nesting_level_; }
+  bool decrement_level() { return --nesting_level_ == 0; }
+
  private:
   bool assert_states_[LAST_PER_THREAD_ASSERT_TYPE];
+  int nesting_level_;
 
   DISALLOW_COPY_AND_ASSIGN(PerThreadAssertData);
 };
 #endif  // DEBUG
 
 
 class PerThreadAssertScopeBase {
 #ifdef DEBUG
+
  protected:
+  PerThreadAssertScopeBase() {
+    data_ = AssertData();
+    data_->increment_level();
+  }
+
+  ~PerThreadAssertScopeBase() {
+    if (!data_->decrement_level()) return;
+    for (int i = 0; i < LAST_PER_THREAD_ASSERT_TYPE; i++) {
+      ASSERT(data_->get(static_cast<PerThreadAssertType>(i)));
+    }
+    delete data_;
+    Thread::SetThreadLocal(thread_local_key, NULL);
+  }
+
   static PerThreadAssertData* AssertData() {
     PerThreadAssertData* data = reinterpret_cast<PerThreadAssertData*>(
             Thread::GetThreadLocal(thread_local_key));
     if (data == NULL) {
       data = new PerThreadAssertData();
       Thread::SetThreadLocal(thread_local_key, data);
     }
     return data;
   }
 
   static Thread::LocalStorageKey thread_local_key;
+  PerThreadAssertData* data_;
   friend class Isolate;
 #endif  // DEBUG
 };
 
 
 
 template <PerThreadAssertType type, bool allow>
 class PerThreadAssertScope : public PerThreadAssertScopeBase {
  public:
 #ifndef DEBUG
   PerThreadAssertScope() { }
   static void SetIsAllowed(bool is_allowed) { }
 #else
   PerThreadAssertScope() {
-    PerThreadAssertData* data = AssertData();
-    old_state_ = data->get(type);
-    data->set(type, allow);
+    old_state_ = data_->get(type);
+    data_->set(type, allow);
   }
 
-  ~PerThreadAssertScope() { AssertData()->set(type, old_state_); }
+  ~PerThreadAssertScope() { data_->set(type, old_state_); }
 
   static bool IsAllowed() { return AssertData()->get(type); }
 
  private:
   bool old_state_;
 #endif
 };
 
 // Scope to document where we do not expect handles to be created.
 typedef PerThreadAssertScope<HANDLE_ALLOCATION_ASSERT, false>
@@ skipping 23 matching lines @@
 typedef PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, false>
     DisallowDeferredHandleDereference;
 
 // Scope to introduce an exception to DisallowDeferredHandleDereference.
 typedef PerThreadAssertScope<DEFERRED_HANDLE_DEREFERENCE_ASSERT, true>
     AllowDeferredHandleDereference;
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSERT_SCOPE_H_