Represent speed in GCTracer functions as double instead of int.

src/heap/gc-idle-time-handler.h

 // Copyright 2014 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.
 
 #ifndef V8_HEAP_GC_IDLE_TIME_HANDLER_H_
 #define V8_HEAP_GC_IDLE_TIME_HANDLER_H_
 
 #include "src/globals.h"
 
 namespace v8 {
@@ skipping 72 matching lines @@
 
   // If we haven't recorded any mark-compact events yet, we use
   // conservative lower bound for the mark-compact speed.
   static const size_t kInitialConservativeMarkCompactSpeed = 2 * MB;
 
   // If we haven't recorded any final incremental mark-compact events yet, we
   // use conservative lower bound for the mark-compact speed.
   static const size_t kInitialConservativeFinalIncrementalMarkCompactSpeed =
       2 * MB;
 
-  // Maximum mark-compact time returned by EstimateMarkCompactTime.
-  static const size_t kMaxMarkCompactTimeInMs;
-
   // Maximum final incremental mark-compact time returned by
   // EstimateFinalIncrementalMarkCompactTime.
   static const size_t kMaxFinalIncrementalMarkCompactTimeInMs;
 
   // This is the maximum scheduled idle time. Note that it can be more than
   // 16.66 ms when there is currently no rendering going on.
   static const size_t kMaxScheduledIdleTime = 50;
 
   // The maximum idle time when frames are rendered is 16.66ms.
   static const size_t kMaxFrameRenderingIdleTime = 17;
@@ skipping 17 matching lines @@
   // ensure we don't keep scheduling idle tasks and making no progress.
   static const int kMaxNoProgressIdleTimes = 10;
 
   GCIdleTimeHandler() : idle_times_which_made_no_progress_(0) {}
 
   GCIdleTimeAction Compute(double idle_time_in_ms,
                            GCIdleTimeHeapState heap_state);
 
   void ResetNoProgressCounter() { idle_times_which_made_no_progress_ = 0; }
 
-  static size_t EstimateMarkingStepSize(size_t idle_time_in_ms,
-                                        size_t marking_speed_in_bytes_per_ms);
+  static size_t EstimateMarkingStepSize(double idle_time_in_ms,
+                                        double marking_speed_in_bytes_per_ms);
 
-  static size_t EstimateMarkCompactTime(
-      size_t size_of_objects, size_t mark_compact_speed_in_bytes_per_ms);
-
-  static size_t EstimateFinalIncrementalMarkCompactTime(
-      size_t size_of_objects, size_t mark_compact_speed_in_bytes_per_ms);
-
-  static bool ShouldDoMarkCompact(size_t idle_time_in_ms,
-                                  size_t size_of_objects,
-                                  size_t mark_compact_speed_in_bytes_per_ms);
+  static double EstimateFinalIncrementalMarkCompactTime(
+      size_t size_of_objects, double mark_compact_speed_in_bytes_per_ms);
 
   static bool ShouldDoContextDisposalMarkCompact(int context_disposed,
                                                  double contexts_disposal_rate);
 
   static bool ShouldDoFinalIncrementalMarkCompact(
-      size_t idle_time_in_ms, size_t size_of_objects,
-      size_t final_incremental_mark_compact_speed_in_bytes_per_ms);
+      double idle_time_in_ms, size_t size_of_objects,
+      double final_incremental_mark_compact_speed_in_bytes_per_ms);
 
-  static bool ShouldDoOverApproximateWeakClosure(size_t idle_time_in_ms);
+  static bool ShouldDoOverApproximateWeakClosure(double idle_time_in_ms);
 
  private:
   GCIdleTimeAction NothingOrDone(double idle_time_in_ms);
 
   // Idle notifications with no progress.
   int idle_times_which_made_no_progress_;
 
   DISALLOW_COPY_AND_ASSIGN(GCIdleTimeHandler);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_GC_IDLE_TIME_HANDLER_H_