Move kMaxRegularHeapObjectSize into globals

test/cctest/heap/test-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 349 matching lines @@
   CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
                                 0));
   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 
   NewSpace new_space(heap);
 
   CHECK(new_space.SetUp(CcTest::heap()->InitialSemiSpaceSize(),
                         CcTest::heap()->InitialSemiSpaceSize()));
   CHECK(new_space.HasBeenSetUp());
 
-  while (new_space.Available() >= Page::kMaxRegularHeapObjectSize) {
-    Object* obj =
-        new_space.AllocateRawUnaligned(Page::kMaxRegularHeapObjectSize)
-            .ToObjectChecked();
+  while (new_space.Available() >= kMaxRegularHeapObjectSize) {
+    Object* obj = new_space.AllocateRawUnaligned(kMaxRegularHeapObjectSize)
+                      .ToObjectChecked();
     CHECK(new_space.Contains(HeapObject::cast(obj)));
   }
 
   new_space.TearDown();
   memory_allocator->TearDown();
   delete memory_allocator;
 }
 
 
 TEST(OldSpace) {
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
   CHECK(memory_allocator->SetUp(heap->MaxReserved(), heap->MaxExecutableSize(),
                                 0));
   TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
 
   OldSpace* s = new OldSpace(heap, OLD_SPACE, NOT_EXECUTABLE);
   CHECK(s != NULL);
 
   CHECK(s->SetUp());
 
   while (s->Available() > 0) {
-    s->AllocateRawUnaligned(Page::kMaxRegularHeapObjectSize).ToObjectChecked();
+    s->AllocateRawUnaligned(kMaxRegularHeapObjectSize).ToObjectChecked();
   }
 
   delete s;
   memory_allocator->TearDown();
   delete memory_allocator;
 }
 
 
 TEST(CompactionSpace) {
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 10 matching lines @@
   CHECK(compaction_space->SetUp());
 
   OldSpace* old_space = new OldSpace(heap, OLD_SPACE, NOT_EXECUTABLE);
   CHECK(old_space != NULL);
   CHECK(old_space->SetUp());
 
   // Cannot loop until "Available()" since we initially have 0 bytes available
   // and would thus neither grow, nor be able to allocate an object.
   const int kNumObjects = 100;
   const int kNumObjectsPerPage =
-      compaction_space->AreaSize() / Page::kMaxRegularHeapObjectSize;
+      compaction_space->AreaSize() / kMaxRegularHeapObjectSize;
   const int kExpectedPages =
       (kNumObjects + kNumObjectsPerPage - 1) / kNumObjectsPerPage;
   for (int i = 0; i < kNumObjects; i++) {
-    compaction_space->AllocateRawUnaligned(Page::kMaxRegularHeapObjectSize)
+    compaction_space->AllocateRawUnaligned(kMaxRegularHeapObjectSize)
         .ToObjectChecked();
   }
   int pages_in_old_space = old_space->CountTotalPages();
   int pages_in_compaction_space = compaction_space->CountTotalPages();
   CHECK_EQ(pages_in_compaction_space, kExpectedPages);
   CHECK_LE(pages_in_old_space, 1);
 
   old_space->MergeCompactionSpace(compaction_space);
   CHECK_EQ(old_space->CountTotalPages(),
            pages_in_old_space + pages_in_compaction_space);
@@ skipping 345 matching lines @@
   HeapObject* filler =
       HeapObject::FromAddress(array->address() + array->Size());
   CHECK_EQ(filler->map(), CcTest::heap()->two_pointer_filler_map());
 
   const size_t shrinked = page->ShrinkToHighWaterMark();
   CHECK_EQ(0, shrinked);
 }
 
 }  // namespace internal
 }  // namespace v8