Move platform abstraction to base library

src/incremental-marking.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 481 matching lines @@
           RecordWriteStub::Patch(Code::cast(e), mode);
         }
       }
     }
   }
 }
 
 
 void IncrementalMarking::EnsureMarkingDequeIsCommitted() {
   if (marking_deque_memory_ == NULL) {
-    marking_deque_memory_ = new VirtualMemory(4 * MB);
+    marking_deque_memory_ = new base::VirtualMemory(4 * MB);
   }
   if (!marking_deque_memory_committed_) {
     bool success = marking_deque_memory_->Commit(
         reinterpret_cast<Address>(marking_deque_memory_->address()),
         marking_deque_memory_->size(),
         false);  // Not executable.
     CHECK(success);
     marking_deque_memory_committed_ = true;
   }
 }
@@ skipping 203 matching lines @@
 
     VisitObject(map, obj, obj->SizeFromMap(map));
   }
 }
 
 
 void IncrementalMarking::Hurry() {
   if (state() == MARKING) {
     double start = 0.0;
     if (FLAG_trace_incremental_marking || FLAG_print_cumulative_gc_stat) {
-      start = OS::TimeCurrentMillis();
+      start = base::OS::TimeCurrentMillis();
       if (FLAG_trace_incremental_marking) {
         PrintF("[IncrementalMarking] Hurry\n");
       }
     }
     // TODO(gc) hurry can mark objects it encounters black as mutator
     // was stopped.
     ProcessMarkingDeque();
     state_ = COMPLETE;
     if (FLAG_trace_incremental_marking || FLAG_print_cumulative_gc_stat) {
-      double end = OS::TimeCurrentMillis();
+      double end = base::OS::TimeCurrentMillis();
       double delta = end - start;
       heap_->AddMarkingTime(delta);
       if (FLAG_trace_incremental_marking) {
         PrintF("[IncrementalMarking] Complete (hurry), spent %d ms.\n",
                static_cast<int>(delta));
       }
     }
   }
 
   if (FLAG_cleanup_code_caches_at_gc) {
@@ skipping 122 matching lines @@
       marking_speed_ * Max(allocated_, write_barriers_invoked_since_last_step_);
   allocated_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 
   bytes_scanned_ += bytes_to_process;
 
   double start = 0;
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc ||
       FLAG_print_cumulative_gc_stat) {
-    start = OS::TimeCurrentMillis();
+    start = base::OS::TimeCurrentMillis();
   }
 
   if (state_ == SWEEPING) {
     if (heap_->mark_compact_collector()->IsConcurrentSweepingInProgress() &&
         heap_->mark_compact_collector()->IsSweepingCompleted()) {
       heap_->mark_compact_collector()->WaitUntilSweepingCompleted();
     }
     if (!heap_->mark_compact_collector()->IsConcurrentSweepingInProgress()) {
       bytes_scanned_ = 0;
       StartMarking(PREVENT_COMPACTION);
@@ skipping 64 matching lines @@
           Min(kMaxMarkingSpeed,
               static_cast<intptr_t>(marking_speed_ * 1.3)));
       if (FLAG_trace_gc) {
         PrintPID("Marking speed increased to %d\n", marking_speed_);
       }
     }
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc ||
       FLAG_print_cumulative_gc_stat) {
-    double end = OS::TimeCurrentMillis();
+    double end = base::OS::TimeCurrentMillis();
     double delta = (end - start);
     longest_step_ = Max(longest_step_, delta);
     steps_took_ += delta;
     steps_took_since_last_gc_ += delta;
     heap_->AddMarkingTime(delta);
   }
 }
 
 
 void IncrementalMarking::ResetStepCounters() {
@@ skipping 11 matching lines @@
   bytes_scanned_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 } }  // namespace v8::internal