Rename NoGCScope -> NoSafepointScope.

runtime/vm/object_graph.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object_graph.h"
 
 #include "vm/dart.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 153 matching lines @@
   isolate->heap()->WriteProtectCode(false);
 }
 
 
 ObjectGraph::~ObjectGraph() {
   isolate()->heap()->WriteProtectCode(true);
 }
 
 
 void ObjectGraph::IterateObjects(ObjectGraph::Visitor* visitor) {
-  NoGCScope no_gc_scope_;
+  NoSafepointScope no_safepoint_scope_;
   Stack stack(isolate());
   isolate()->VisitObjectPointers(&stack, false, false);
   stack.TraverseGraph(visitor);
   Unmarker::UnmarkAll(isolate());
 }
 
 
 void ObjectGraph::IterateObjectsFrom(const Object& root,
                                      ObjectGraph::Visitor* visitor) {
-  NoGCScope no_gc_scope_;
+  NoSafepointScope no_safepoint_scope_;
   Stack stack(isolate());
   RawObject* root_raw = root.raw();
   stack.VisitPointer(&root_raw);
   stack.TraverseGraph(visitor);
   // TODO(koda): Optimize if we only visited a small subgraph.
   Unmarker::UnmarkAll(isolate());
 }
 
 
 class SizeVisitor : public ObjectGraph::Visitor {
@@ skipping 54 matching lines @@
   intptr_t size_excluding_class = excluding_class.size();
   return size_total - size_excluding_class;
 }
 
 
 class RetainingPathVisitor : public ObjectGraph::Visitor {
  public:
   // We cannot use a GrowableObjectArray, since we must not trigger GC.
   RetainingPathVisitor(RawObject* obj, const Array& path)
       : obj_(obj), path_(path), length_(0) {
-    ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
+    ASSERT(Isolate::Current()->no_safepoint_scope_depth() != 0);
   }
 
   intptr_t length() const { return length_; }
 
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     if (it->Get() != obj_) {
       return kProceed;
     } else {
       HANDLESCOPE(Isolate::Current());
       Object& current = Object::Handle();
@@ skipping 14 matching lines @@
   }
 
  private:
   RawObject* obj_;
   const Array& path_;
   intptr_t length_;
 };
 
 
 intptr_t ObjectGraph::RetainingPath(Object* obj, const Array& path) {
-  NoGCScope no_gc_scope_;
+  NoSafepointScope no_safepoint_scope_;
   // To break the trivial path, the handle 'obj' is temporarily cleared during
   // the search, but restored before returning.
   RawObject* raw = obj->raw();
   *obj = Object::null();
   RetainingPathVisitor visitor(raw, path);
   IterateObjects(&visitor);
   *obj = raw;
   return visitor.length();
 }
 
 
 class InboundReferencesVisitor : public ObjectVisitor,
                                  public ObjectPointerVisitor {
  public:
   // We cannot use a GrowableObjectArray, since we must not trigger GC.
   InboundReferencesVisitor(Isolate* isolate,
                            RawObject* target,
                            const Array& references,
                            Object* scratch)
     : ObjectVisitor(isolate), ObjectPointerVisitor(isolate), source_(NULL),
       target_(target), references_(references), scratch_(scratch), length_(0) {
-    ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);
+    ASSERT(Isolate::Current()->no_safepoint_scope_depth() != 0);
   }
 
   intptr_t length() const { return length_; }
 
   virtual void VisitObject(RawObject* raw_obj) {
     source_ = raw_obj;
     raw_obj->VisitPointers(this);
   }
 
   virtual void VisitPointers(RawObject** first, RawObject** last) {
@@ skipping 31 matching lines @@
   RawObject* source_;
   RawObject* target_;
   const Array& references_;
   Object* scratch_;
   intptr_t length_;
 };
 
 
 intptr_t ObjectGraph::InboundReferences(Object* obj, const Array& references) {
   Object& scratch = Object::Handle();
-  NoGCScope no_gc_scope_;
+  NoSafepointScope no_safepoint_scope_;
   InboundReferencesVisitor visitor(isolate(), obj->raw(), references, &scratch);
   isolate()->heap()->IterateObjects(&visitor);
   return visitor.length();
 }
 
 
 static void WritePtr(RawObject* raw, WriteStream* stream) {
   ASSERT(raw->IsHeapObject());
   ASSERT(raw->IsOldObject());
   uword addr = RawObject::ToAddr(raw);
@@ skipping 76 matching lines @@
   stream->WriteUnsigned(0);
   {
     WritePointerVisitor ptr_writer(isolate(), stream);
     isolate()->VisitObjectPointers(&ptr_writer, false, false);
   }
   stream->WriteUnsigned(0);
   IterateObjects(&visitor);
 }
 
 }  // namespace dart