Fix memory leak in assert scopes.

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 60 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PerThreadAssertData);
 };
 #endif  // DEBUG
 
 
 class PerThreadAssertScopeBase {
 #ifdef DEBUG
 
  protected:
+  enum AcquireAssertDataMode { CREATE_IF_ABSENT, NULL_IF_ABSENT };

[Sven Panne, 2013/06/12 09:41:17]

Nuke this.

+
   PerThreadAssertScopeBase() {
-    data_ = AssertData();
+    data_ = GetAssertData();
+    if (data_ == NULL) {
+      data_ = new PerThreadAssertData();
+      Thread::SetThreadLocal(thread_local_key, data_);

[Sven Panne, 2013/06/12 09:41:17]

Put the TLS write into a private method and use it here...

+    }
     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);

[Sven Panne, 2013/06/12 09:41:17]

... and here.

   }
 
-  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 PerThreadAssertData* GetAssertData() {
+    return reinterpret_cast<PerThreadAssertData*>(
+        Thread::GetThreadLocal(thread_local_key));
   }
 
   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() {
     old_state_ = data_->get(type);
     data_->set(type, allow);
   }
 
   ~PerThreadAssertScope() { data_->set(type, old_state_); }
 
-  static bool IsAllowed() { return AssertData()->get(type); }
+  static bool IsAllowed() {
+    PerThreadAssertData* data = GetAssertData();
+    return data == NULL || data->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>
     DisallowHandleAllocation;
 
@@ skipping 21 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_