[test] Move away from deprecated API for heap-related tests.

test/cctest/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 18 matching lines @@
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include <stdlib.h>
 
 #include "src/base/platform/platform.h"
 #include "src/snapshot/snapshot.h"
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap-tester.h"
 
-using namespace v8::internal;
+namespace v8 {
+namespace internal {
 
 #if 0
 static void VerifyRegionMarking(Address page_start) {
 #ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   Page* p = Page::FromAddress(page_start);
 
   p->SetRegionMarks(Page::kAllRegionsCleanMarks);
 
   for (Address addr = p->ObjectAreaStart();
        addr < p->ObjectAreaEnd();
@@ skipping 47 matching lines @@
   CHECK(p->OffsetToAddress(Page::kPageSize) == p->ObjectAreaEnd());
 
   // test region marking
   VerifyRegionMarking(page_start);
 
   DeleteArray(mem);
 }
 #endif
 
 
-namespace v8 {
-namespace internal {
-
 // Temporarily sets a given allocator in an isolate.
 class TestMemoryAllocatorScope {
  public:
   TestMemoryAllocatorScope(Isolate* isolate, MemoryAllocator* allocator)
       : isolate_(isolate),
         old_allocator_(isolate->memory_allocator_) {
     isolate->memory_allocator_ = allocator;
   }
 
   ~TestMemoryAllocatorScope() {
@@ skipping 21 matching lines @@
     isolate_->code_range_ = old_code_range_;
   }
 
  private:
   Isolate* isolate_;
   CodeRange* old_code_range_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCodeRangeScope);
 };
 
-}  // namespace internal
-}  // namespace v8
-
 
 static void VerifyMemoryChunk(Isolate* isolate,
                               Heap* heap,
                               CodeRange* code_range,
                               size_t reserve_area_size,
                               size_t commit_area_size,
                               size_t second_commit_area_size,
                               Executability executable) {
   MemoryAllocator* memory_allocator = new MemoryAllocator(isolate);
   CHECK(memory_allocator->SetUp(heap->MaxReserved(),
                                 heap->MaxExecutableSize()));
   TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
   TestCodeRangeScope test_code_range_scope(isolate, code_range);
 
   size_t header_size = (executable == EXECUTABLE)
                        ? MemoryAllocator::CodePageGuardStartOffset()
                        : MemoryChunk::kObjectStartOffset;
   size_t guard_size = (executable == EXECUTABLE)
                        ? MemoryAllocator::CodePageGuardSize()
                        : 0;
 
   MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(reserve_area_size,
                                                               commit_area_size,
                                                               executable,
                                                               NULL);
-  size_t alignment = code_range != NULL && code_range->valid() ?
-                     MemoryChunk::kAlignment : v8::base::OS::CommitPageSize();
+  size_t alignment = code_range != NULL && code_range->valid()
+                         ? MemoryChunk::kAlignment
+                         : base::OS::CommitPageSize();
   size_t reserved_size =
       ((executable == EXECUTABLE))
           ? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
                     alignment)
           : RoundUp(header_size + reserve_area_size,
-                    v8::base::OS::CommitPageSize());
+                    base::OS::CommitPageSize());
   CHECK(memory_chunk->size() == reserved_size);
   CHECK(memory_chunk->area_start() < memory_chunk->address() +
                                      memory_chunk->size());
   CHECK(memory_chunk->area_end() <= memory_chunk->address() +
                                     memory_chunk->size());
   CHECK(static_cast<size_t>(memory_chunk->area_size()) == commit_area_size);
 
   Address area_start = memory_chunk->area_start();
 
   memory_chunk->CommitArea(second_commit_area_size);
@@ skipping 684 matching lines @@
     CHECK_EQ(observer1.count(), 16);  // no more notifications.
     CHECK_EQ(observer2.count(), 3);   // this one is still active.
 
     new_space->RemoveInlineAllocationObserver(&observer2);
     AllocateUnaligned(new_space, 384);
     CHECK_EQ(observer1.count(), 16);
     CHECK_EQ(observer2.count(), 3);
   }
   isolate->Dispose();
 }
+
+}  // namespace internal
+}  // namespace v8