Make assertion scopes thread safe.

src/heap.h

 // Copyright 2012 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_HEAP_H_
 #define V8_HEAP_H_
 
 #include <cmath>
 
 #include "allocation.h"
+#include "assert-scope.h"
 #include "globals.h"
 #include "incremental-marking.h"
 #include "list.h"
 #include "mark-compact.h"
 #include "objects-visiting.h"
 #include "spaces.h"
 #include "splay-tree-inl.h"
 #include "store-buffer.h"
 #include "v8-counters.h"
 #include "v8globals.h"
@@ skipping 1445 matching lines @@
 
   // Given an address occupied by a live code object, return that object.
   Object* FindCodeObject(Address a);
 
   enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT };
   inline HeapState gc_state() { return gc_state_; }
 
   inline bool IsInGCPostProcessing() { return gc_post_processing_depth_ > 0; }
 
 #ifdef DEBUG
-  bool IsAllocationAllowed() { return allocation_allowed_; }
-  inline void set_allow_allocation(bool allocation_allowed);
-  inline bool allow_allocation(bool enable);
-
   bool disallow_allocation_failure() {
     return disallow_allocation_failure_;
   }
 
   void TracePathToObjectFrom(Object* target, Object* root);
   void TracePathToObject(Object* target);
   void TracePathToGlobal();
 #endif
 
   // Callback function passed to Heap::Iterate etc.  Copies an object if
@@ skipping 459 matching lines @@
   inline void set_##name(type* value) {                                        \
     /* The deserializer makes use of the fact that these common roots are */   \
     /* never in new space and never on a page that is being compacted.    */   \
     ASSERT(k##camel_name##RootIndex >= kOldSpaceRoots || !InNewSpace(value));  \
     roots_[k##camel_name##RootIndex] = value;                                  \
   }
   ROOT_LIST(ROOT_ACCESSOR)
 #undef ROOT_ACCESSOR
 
 #ifdef DEBUG
-  bool allocation_allowed_;
-
   // If the --gc-interval flag is set to a positive value, this
   // variable holds the value indicating the number of allocations
   // remain until the next failure and garbage collection.
   int allocation_timeout_;
 
   // Do we expect to be able to handle allocation failure at this
   // time?
   bool disallow_allocation_failure_;
 #endif  // DEBUG
 
@@ skipping 696 matching lines @@
   };
 
   Key keys_[kLength];
   int results_[kLength];
 
   friend class Isolate;
   DISALLOW_COPY_AND_ASSIGN(DescriptorLookupCache);
 };
 
 
-// A helper class to document/test C++ scopes where we do not
-// expect a GC. Usage:
-//
-// /* Allocation not allowed: we cannot handle a GC in this scope. */
-// { AssertNoAllocation nogc;
-//   ...
-// }
-
-#ifdef DEBUG
-inline bool EnterAllocationScope(Isolate* isolate, bool allow_allocation);
-inline void ExitAllocationScope(Isolate* isolate, bool last_state);
-#endif
-
-
-class AssertNoAllocation {
- public:
-  inline AssertNoAllocation();
-  inline ~AssertNoAllocation();
-
-#ifdef DEBUG
- private:
-  bool last_state_;
-#endif
-};
-
-
-class DisableAssertNoAllocation {
- public:
-  inline DisableAssertNoAllocation();
-  inline ~DisableAssertNoAllocation();
-
-#ifdef DEBUG
- private:
-  bool last_state_;
-#endif
-};
-
 // GCTracer collects and prints ONE line after each garbage collector
 // invocation IFF --trace_gc is used.
 
 class GCTracer BASE_EMBEDDED {
  public:
   class Scope BASE_EMBEDDED {
    public:
     enum ScopeId {
       EXTERNAL,
       MC_MARK,
@@ skipping 294 matching lines @@
   // done for all matches.
   PathTracer(Object* search_target,
              WhatToFind what_to_find,
              VisitMode visit_mode)
       : search_target_(search_target),
         found_target_(false),
         found_target_in_trace_(false),
         what_to_find_(what_to_find),
         visit_mode_(visit_mode),
         object_stack_(20),
-        no_alloc() {}
+        no_allocation() {}
 
   virtual void VisitPointers(Object** start, Object** end);
 
   void Reset();
   void TracePathFrom(Object** root);
 
   bool found() const { return found_target_; }
 
   static Object* const kAnyGlobalObject;
 
  protected:
   class MarkVisitor;
   class UnmarkVisitor;
 
   void MarkRecursively(Object** p, MarkVisitor* mark_visitor);
   void UnmarkRecursively(Object** p, UnmarkVisitor* unmark_visitor);
   virtual void ProcessResults();
 
   // Tags 0, 1, and 3 are used. Use 2 for marking visited HeapObject.
   static const int kMarkTag = 2;
 
   Object* search_target_;
   bool found_target_;
   bool found_target_in_trace_;
   WhatToFind what_to_find_;
   VisitMode visit_mode_;
   List<Object*> object_stack_;
 
-  AssertNoAllocation no_alloc;  // i.e. no gc allowed.
+  DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_