Refactor only: Rename JSGlobaPropertyCell to PropertyCell

src/heap.cc

 // 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 1375 matching lines @@
       scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(value_address));
     }
   }
 
   // Copy objects reachable from global property cells by scavenging global
   // property cell values directly.
   HeapObjectIterator js_global_property_cell_iterator(property_cell_space_);
   for (HeapObject* heap_object = js_global_property_cell_iterator.Next();
        heap_object != NULL;
        heap_object = js_global_property_cell_iterator.Next()) {
-    if (heap_object->IsJSGlobalPropertyCell()) {
-      JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(heap_object);
+    if (heap_object->IsPropertyCell()) {
+      PropertyCell* cell = PropertyCell::cast(heap_object);
       Address value_address = cell->ValueAddress();
       scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(value_address));
       Address type_address = cell->TypeAddress();
       scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(type_address));
     }
   }
 
   // Copy objects reachable from the code flushing candidates list.
   MarkCompactCollector* collector = mark_compact_collector();
   if (collector->is_code_flushing_enabled()) {
@@ skipping 1262 matching lines @@
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_code_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(CELL_TYPE, Cell::kSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_cell_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(PROPERTY_CELL_TYPE,
-                                         JSGlobalPropertyCell::kSize);
+                                         PropertyCell::kSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_global_property_cell_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(FILLER_TYPE, kPointerSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_one_pointer_filler_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(FILLER_TYPE, 2 * kPointerSize);
@@ skipping 124 matching lines @@
   Object* result;
   { MaybeObject* maybe_result = AllocateRawCell();
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   HeapObject::cast(result)->set_map_no_write_barrier(cell_map());
   Cell::cast(result)->set_value(value);
   return result;
 }
 
 
-MaybeObject* Heap::AllocateJSGlobalPropertyCell(Object* value) {
+MaybeObject* Heap::AllocatePropertyCell(Object* value) {
   Object* result;
-  { MaybeObject* maybe_result = AllocateRawJSGlobalPropertyCell();
+  { MaybeObject* maybe_result = AllocateRawPropertyCell();
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   HeapObject::cast(result)->set_map_no_write_barrier(
       global_property_cell_map());
-  JSGlobalPropertyCell::cast(result)->set_value(value);
-  JSGlobalPropertyCell::cast(result)->set_type(Type::None());
+  PropertyCell::cast(result)->set_value(value);
+  PropertyCell::cast(result)->set_type(Type::None());
   return result;
 }
 
 
 MaybeObject* Heap::AllocateBox(Object* value, PretenureFlag pretenure) {
   Box* result;
   MaybeObject* maybe_result = AllocateStruct(BOX_TYPE);
   if (!maybe_result->To(&result)) return maybe_result;
   result->set_value(value);
   return result;
@@ skipping 1872 matching lines @@
 }
 
 
 MaybeObject* Heap::AllocateGlobalObject(JSFunction* constructor) {
   ASSERT(constructor->has_initial_map());
   Map* map = constructor->initial_map();
   ASSERT(map->is_dictionary_map());
 
   // Make sure no field properties are described in the initial map.
   // This guarantees us that normalizing the properties does not
-  // require us to change property values to JSGlobalPropertyCells.
+  // require us to change property values to PropertyCells.
   ASSERT(map->NextFreePropertyIndex() == 0);
 
   // Make sure we don't have a ton of pre-allocated slots in the
   // global objects. They will be unused once we normalize the object.
   ASSERT(map->unused_property_fields() == 0);
   ASSERT(map->inobject_properties() == 0);
 
   // Initial size of the backing store to avoid resize of the storage during
   // bootstrapping. The size differs between the JS global object ad the
   // builtins object.
   int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
 
   // Allocate a dictionary object for backing storage.
   NameDictionary* dictionary;
   MaybeObject* maybe_dictionary =
       NameDictionary::Allocate(
           this,
           map->NumberOfOwnDescriptors() * 2 + initial_size);
   if (!maybe_dictionary->To(&dictionary)) return maybe_dictionary;
 
   // The global object might be created from an object template with accessors.
   // Fill these accessors into the dictionary.
   DescriptorArray* descs = map->instance_descriptors();
   for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
     PropertyDetails details = descs->GetDetails(i);
     ASSERT(details.type() == CALLBACKS);  // Only accessors are expected.
     PropertyDetails d = PropertyDetails(details.attributes(), CALLBACKS, i + 1);
     Object* value = descs->GetCallbacksObject(i);
-    MaybeObject* maybe_value = AllocateJSGlobalPropertyCell(value);
+    MaybeObject* maybe_value = AllocatePropertyCell(value);
     if (!maybe_value->ToObject(&value)) return maybe_value;
 
     MaybeObject* maybe_added = dictionary->Add(descs->GetKey(i), value, d);
     if (!maybe_added->To(&dictionary)) return maybe_added;
   }
 
   // Allocate the global object and initialize it with the backing store.
   JSObject* global;
   MaybeObject* maybe_global = Allocate(map, OLD_POINTER_SPACE);
   if (!maybe_global->To(&global)) return maybe_global;
@@ skipping 1303 matching lines @@
   PrintF("Old pointer space : ");
   old_pointer_space_->ReportStatistics();
   PrintF("Old data space : ");
   old_data_space_->ReportStatistics();
   PrintF("Code space : ");
   code_space_->ReportStatistics();
   PrintF("Map space : ");
   map_space_->ReportStatistics();
   PrintF("Cell space : ");
   cell_space_->ReportStatistics();
-  PrintF("JSGlobalPropertyCell space : ");
+  PrintF("PropertyCell space : ");
   property_cell_space_->ReportStatistics();
   PrintF("Large object space : ");
   lo_space_->ReportStatistics();
   PrintF(">>>>>> ========================================= >>>>>>\n");
 }
 
 #endif  // DEBUG
 
 bool Heap::Contains(HeapObject* value) {
   return Contains(value->address());
@@ skipping 1978 matching lines @@
   if (FLAG_parallel_recompilation) {
     heap_->relocation_mutex_->Lock();
 #ifdef DEBUG
     heap_->relocation_mutex_locked_by_optimizer_thread_ =
         heap_->isolate()->optimizing_compiler_thread()->IsOptimizerThread();
 #endif  // DEBUG
   }
 }
 
 } }  // namespace v8::internal