Perform TODO(gc) cleanup for TODO-lockdown.

src/spaces.cc

 // Copyright 2011 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 739 matching lines @@
   while (it.has_next()) {
     it.next();
     count++;
   }
   return count;
 }
 #endif
 
 
 void PagedSpace::Shrink() {
-  // TODO(gc) release half of pages?
+  // TODO(1614) Not implemented.
 }
 
 
 bool PagedSpace::EnsureCapacity(int capacity) {
   while (Capacity() < capacity) {
     // Expand the space until it has the required capacity or expansion fails.
     if (!Expand()) return false;
   }
   return true;
 }
@@ skipping 1531 matching lines @@
         space, kAllocationActionFree, page->size());
     heap()->isolate()->memory_allocator()->Free(page);
   }
 
   size_ = 0;
   page_count_ = 0;
   objects_size_ = 0;
 }
 
 
-MaybeObject* LargeObjectSpace::AllocateRawInternal(int object_size,
-                                                   Executability executable) {
+MaybeObject* LargeObjectSpace::AllocateRaw(int object_size,
+                                           Executability executable) {
   // Check if we want to force a GC before growing the old space further.
   // If so, fail the allocation.
   if (!heap()->always_allocate() &&
       heap()->OldGenerationAllocationLimitReached()) {
     return Failure::RetryAfterGC(identity());
   }
 
-  // TODO(gc) isolates merge
   LargePage* page = heap()->isolate()->memory_allocator()->
       AllocateLargePage(object_size, executable, this);
   if (page == NULL) return Failure::RetryAfterGC(identity());
   ASSERT(page->body_size() >= object_size);
 
   size_ += static_cast<int>(page->size());
   objects_size_ += object_size;
   page_count_++;
   page->set_next_page(first_page_);
   first_page_ = page;
 
 
   heap()->incremental_marking()->OldSpaceStep(object_size);
   return page->GetObject();
 }
 
 
-MaybeObject* LargeObjectSpace::AllocateRawCode(int size_in_bytes) {
-  ASSERT(0 < size_in_bytes);
-  return AllocateRawInternal(size_in_bytes, EXECUTABLE);
-}
-
-
-MaybeObject* LargeObjectSpace::AllocateRawFixedArray(int size_in_bytes) {
-  ASSERT(0 < size_in_bytes);
-  return AllocateRawInternal(size_in_bytes, NOT_EXECUTABLE);
-}
-
-
-MaybeObject* LargeObjectSpace::AllocateRawData(int size_in_bytes) {
-  ASSERT(0 < size_in_bytes);
-  return AllocateRawInternal(size_in_bytes, NOT_EXECUTABLE);
-}
-
-
 // GC support
 MaybeObject* LargeObjectSpace::FindObject(Address a) {
   for (LargePage* page = first_page_;
        page != NULL;
        page = page->next_page()) {
     Address page_address = page->address();
     if (page_address <= a && a < page_address + page->size()) {
       return page->GetObject();
     }
   }
@@ skipping 150 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal