Rename NoGCScope -> NoSafepointScope.

runtime/vm/pages.cc

 // Copyright (c) 2012, 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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 430 matching lines @@
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = space_->NextPageAnySize(page_);
   }
  private:
   const PageSpace* space_;
   MutexLocker ml_;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
 
 // Provides exclusive access to code pages, and ensures they are walkable.
 // NOTE: This does not iterate over large pages which can contain code.
 class ExclusiveCodePageIterator : ValueObject {
  public:
   explicit ExclusiveCodePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->exec_pages_;
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = page_->next();
   }
  private:
   const PageSpace* space_;
   MutexLocker ml_;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
 
 // Provides exclusive access to large pages, and ensures they are walkable.
 class ExclusiveLargePageIterator : ValueObject {
  public:
   explicit ExclusiveLargePageIterator(const PageSpace* space)
       : space_(space), ml_(space->pages_lock_) {
     space_->MakeIterable();
     page_ = space_->large_pages_;
   }
   HeapPage* page() const { return page_; }
   bool Done() const { return page_ == NULL; }
   void Advance() {
     ASSERT(!Done());
     page_ = page_->next();
   }
  private:
   const PageSpace* space_;
   MutexLocker ml_;
-  NoGCScope no_gc;
+  NoSafepointScope no_safepoint;
   HeapPage* page_;
 };
 
 
 void PageSpace::MakeIterable() const {
   // Assert not called from concurrent sweeper task.
   // TODO(koda): Use thread/task identity when implemented.
   ASSERT(Isolate::Current()->heap() != NULL);
   if (bump_top_ < bump_end_) {
     FreeListElement::AsElement(bump_top_, bump_end_ - bump_top_);
@@ skipping 156 matching lines @@
   {
     JSONObject class_list(&heap_map, "class_list");
     isolate->class_table()->PrintToJSONObject(&class_list);
   }
   {
     // "pages" is an array [page0, page1, ..., pageN], each page of the form
     // {"object_start": "0x...", "objects": [size, class id, size, ...]}
     // TODO(19445): Use ExclusivePageIterator once HeapMap supports large pages.
     MutexLocker ml(pages_lock_);
     MakeIterable();
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     JSONArray all_pages(&heap_map, "pages");
     for (HeapPage* page = pages_; page != NULL; page = page->next()) {
       JSONObject page_container(&all_pages);
       page_container.AddPropertyF("object_start",
                                   "0x%" Px "", page->object_start());
       JSONArray page_map(&page_container, "objects");
       HeapMapAsJSONVisitor printer(&page_map);
       page->VisitObjects(&printer);
     }
     for (HeapPage* page = exec_pages_; page != NULL; page = page->next()) {
@@ skipping 22 matching lines @@
     page_space_controller_.set_last_code_collection_in_us(start);
     return true;
   }
   return false;
 }
 
 
 void PageSpace::WriteProtectCode(bool read_only) {
   if (FLAG_write_protect_code) {
     MutexLocker ml(pages_lock_);
-    NoGCScope no_gc;
+    NoSafepointScope no_safepoint;
     // No need to go through all of the data pages first.
     HeapPage* page = exec_pages_;
     while (page != NULL) {
       ASSERT(page->type() == HeapPage::kExecutable);
       page->WriteProtect(read_only);
       page = page->next();
     }
     page = large_pages_;
     while (page != NULL) {
       if (page->type() == HeapPage::kExecutable) {
@@ skipping 390 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>((static_cast<double>(gc_time) /
                                    static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart