Rename references to "external pages" as "snapshot pages" to avoid confusion with the kind of exter…

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/address_sanitizer.h"
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
@@ skipping 75 matching lines @@
   HeapPage* result = Initialize(memory, type);
   if (result == NULL) {
     delete memory;  // Release reservation to OS.
     return NULL;
   }
   return result;
 }
 
 
 void HeapPage::Deallocate() {
-  bool is_embedder_allocated = embedder_allocated();
+  bool image_page = is_image_page();
 
-  if (!is_embedder_allocated) {
+  if (!image_page) {
     LSAN_UNREGISTER_ROOT_REGION(this, sizeof(*this));
   }
 
   // For a regular heap pages, the memory for this object will become
   // unavailable after the delete below.
   delete memory_;
 
   // For a heap page from a snapshot, the HeapPage object lives in the malloc
   // heap rather than the page itself.
-  if (is_embedder_allocated) {
+  if (image_page) {
     free(this);
   }
 }
 
 
 void HeapPage::VisitObjects(ObjectVisitor* visitor) const {
   NoSafepointScope no_safepoint;
   uword obj_addr = object_start();
   uword end_addr = object_end();
   while (obj_addr < end_addr) {
@@ skipping 30 matching lines @@
       }
       obj_addr = next_obj_addr;
     }
     ASSERT(obj_addr == end_addr);
   }
   return Object::null();
 }
 
 
 void HeapPage::WriteProtect(bool read_only) {
-  ASSERT(!embedder_allocated());
+  ASSERT(!is_image_page());
 
   VirtualMemory::Protection prot;
   if (read_only) {
     if (type_ == kExecutable) {
       prot = VirtualMemory::kReadExecute;
     } else {
       prot = VirtualMemory::kReadOnly;
     }
   } else {
     prot = VirtualMemory::kReadWrite;
@@ skipping 74 matching lines @@
     }
     pages_tail_ = page;
   } else {
     // Should not allocate executable pages when running from a precompiled
     // snapshot.
     ASSERT(Dart::vm_snapshot_kind() != Snapshot::kAppAOT);
 
     if (exec_pages_ == NULL) {
       exec_pages_ = page;
     } else {
-      if (FLAG_write_protect_code && !exec_pages_tail_->embedder_allocated()) {
+      if (FLAG_write_protect_code && !exec_pages_tail_->is_image_page()) {
         exec_pages_tail_->WriteProtect(false);
       }
       exec_pages_tail_->set_next(page);
-      if (FLAG_write_protect_code && !exec_pages_tail_->embedder_allocated()) {
+      if (FLAG_write_protect_code && !exec_pages_tail_->is_image_page()) {
         exec_pages_tail_->WriteProtect(true);
       }
     }
     exec_pages_tail_ = page;
   }
   IncreaseCapacityInWordsLocked(kPageSizeInWords);
   page->set_object_end(page->memory_->end());
   return page;
 }
 
@@ skipping 367 matching lines @@
 }
 
 
 void PageSpace::VisitObjects(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjects(visitor);
   }
 }
 
 
-void PageSpace::VisitObjectsNoExternalPages(ObjectVisitor* visitor) const {
+void PageSpace::VisitObjectsNoImagePages(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
-    if (!it.page()->embedder_allocated()) {
+    if (!it.page()->is_image_page()) {
       it.page()->VisitObjects(visitor);
     }
   }
 }
 
 
-void PageSpace::VisitObjectsExternalPages(ObjectVisitor* visitor) const {
+void PageSpace::VisitObjectsImagePages(ObjectVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
-    if (it.page()->embedder_allocated()) {
+    if (it.page()->is_image_page()) {
       it.page()->VisitObjects(visitor);
     }
   }
 }
 
 
 void PageSpace::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
     it.page()->VisitObjectPointers(visitor);
   }
@@ skipping 33 matching lines @@
   return Object::null();
 }
 
 
 void PageSpace::WriteProtect(bool read_only) {
   if (read_only) {
     // Avoid MakeIterable trying to write to the heap.
     AbandonBumpAllocation();
   }
   for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
-    if (!it.page()->embedder_allocated()) {
+    if (!it.page()->is_image_page()) {
       it.page()->WriteProtect(read_only);
     }
   }
 }
 
 
 #ifndef PRODUCT
 void PageSpace::PrintToJSONObject(JSONObject* object) const {
   if (!FLAG_support_service) {
     return;
@@ skipping 99 matching lines @@
 
 
 void PageSpace::WriteProtectCode(bool read_only) {
   if (FLAG_write_protect_code) {
     MutexLocker ml(pages_lock_);
     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);
-      if (!page->embedder_allocated()) {
+      if (!page->is_image_page()) {
         page->WriteProtect(read_only);
       }
       page = page->next();
     }
     page = large_pages_;
     while (page != NULL) {
-      if (page->type() == HeapPage::kExecutable &&
-          !page->embedder_allocated()) {
+      if (page->type() == HeapPage::kExecutable && !page->is_image_page()) {
         page->WriteProtect(read_only);
       }
       page = page->next();
     }
   }
 }
 
 
 void PageSpace::MarkSweep(bool invoke_api_callbacks) {
   Thread* thread = Thread::Current();
@@ skipping 241 matching lines @@
     AtomicOperations::IncrementBy(&(usage_.used_in_words),
                                   (size >> kWordSizeLog2));
     return result;
   }
   result = TryAllocateDataBumpLocked(size, growth_policy);
   if (result != 0) return result;
   return TryAllocateDataLocked(size, growth_policy);
 }
 
 
-void PageSpace::SetupExternalPage(void* pointer,
-                                  uword size,
-                                  bool is_executable) {
+void PageSpace::SetupImagePage(void* pointer, uword size, bool is_executable) {
   // Setup a HeapPage so precompiled Instructions can be traversed.
   // Instructions are contiguous at [pointer, pointer + size). HeapPage
   // expects to find objects at [memory->start() + ObjectStartOffset,
   // memory->end()).
   uword offset = HeapPage::ObjectStartOffset();
   pointer = reinterpret_cast<void*>(reinterpret_cast<uword>(pointer) - offset);
   size += offset;
 
-  VirtualMemory* memory = VirtualMemory::ForExternalPage(pointer, size);
+  VirtualMemory* memory = VirtualMemory::ForImagePage(pointer, size);
   ASSERT(memory != NULL);
   HeapPage* page = reinterpret_cast<HeapPage*>(malloc(sizeof(HeapPage)));
   page->memory_ = memory;
   page->next_ = NULL;
   page->object_end_ = memory->end();
 
   MutexLocker ml(pages_lock_);
   HeapPage **first, **tail;
   if (is_executable) {
     ASSERT(Utils::IsAligned(pointer, OS::PreferredCodeAlignment()));
     page->type_ = HeapPage::kExecutable;
     first = &exec_pages_;
     tail = &exec_pages_tail_;
   } else {
     page->type_ = HeapPage::kData;
     first = &pages_;
     tail = &pages_tail_;
   }
   if (*first == NULL) {
     *first = page;
   } else {
-    if (is_executable && FLAG_write_protect_code &&
-        !(*tail)->embedder_allocated()) {
+    if (is_executable && FLAG_write_protect_code && !(*tail)->is_image_page()) {
       (*tail)->WriteProtect(false);
     }
     (*tail)->set_next(page);
-    if (is_executable && FLAG_write_protect_code &&
-        !(*tail)->embedder_allocated()) {
+    if (is_executable && FLAG_write_protect_code && !(*tail)->is_image_page()) {
       (*tail)->WriteProtect(true);
     }
   }
   (*tail) = page;
 }
 
 
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
@@ skipping 149 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