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 06:57:37]

This is getting a little bit confusing... I think that instead of introducing
this enum, we should actually just split AssertData() into 2 methods: One for
retrieving PerThreadAssertData from TLS and one putting it into TLS. IsAllowed
simply uses the first method, while the PerThreadAssertScopeBase constructor
uses a combination of the 2 methods.

http://www.refactoring.com/catalog/replaceParameterWithExplicitMethods.html

+
   PerThreadAssertScopeBase() {
-    data_ = AssertData();
+    data_ = AssertData(CREATE_IF_ABSENT);
     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() {
+  static PerThreadAssertData* AssertData(AcquireAssertDataMode mode) {
     PerThreadAssertData* data = reinterpret_cast<PerThreadAssertData*>(
             Thread::GetThreadLocal(thread_local_key));
-    if (data == NULL) {
+    if (data == NULL && mode == CREATE_IF_ABSENT) {
       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() {
     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 = AssertData(NULL_IF_ABSENT);
+    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_