Update GC stats, ThreadPool, Timer and ScopedTimer to use monotonic time.

runtime/vm/thread_pool_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/os.h"
 #include "vm/lockers.h"
 #include "vm/thread_pool.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
-DECLARE_FLAG(int, worker_timeout_millis);
+DECLARE_FLAG(int, worker_timeout_micros);
 
 
 UNIT_TEST_CASE(ThreadPool_Create) {
   ThreadPool thread_pool;
 }
 
 
 class TestTask : public ThreadPool::Task {
  public:
   TestTask(Monitor* sync, bool* done) : sync_(sync), done_(done) {}
@@ skipping 129 matching lines @@
   }
 
   // We should have waited for all the workers to finish, so they all should
   // have had a chance to increment slept_count.
   EXPECT_EQ(kTaskCount, final_count);
 }
 
 
 UNIT_TEST_CASE(ThreadPool_WorkerTimeout) {
   // Adjust the worker timeout so that we timeout quickly.
-  int saved_timeout = FLAG_worker_timeout_millis;
-  FLAG_worker_timeout_millis = 1;
+  int saved_timeout = FLAG_worker_timeout_micros;
+  FLAG_worker_timeout_micros = 1000;
 
   ThreadPool thread_pool;
   EXPECT_EQ(0U, thread_pool.workers_started());
   EXPECT_EQ(0U, thread_pool.workers_stopped());
 
   // Run a worker.
   Monitor sync;
   bool done = true;
   thread_pool.Run(new TestTask(&sync, &done));
   EXPECT_EQ(1U, thread_pool.workers_started());
   EXPECT_EQ(0U, thread_pool.workers_stopped());
   {
     MonitorLocker ml(&sync);
     done = false;
     ml.Notify();
     while (!done) {
       ml.Wait();
     }
   }
   EXPECT(done);
 
   // Wait up to 5 seconds to see if a worker times out.
   const int kMaxWait = 5000;
   int waited = 0;
   while (thread_pool.workers_stopped() == 0 && waited < kMaxWait) {
     OS::Sleep(1);
     waited += 1;
   }
   EXPECT_EQ(1U, thread_pool.workers_stopped());
-  FLAG_worker_timeout_millis = saved_timeout;
+  FLAG_worker_timeout_micros = saved_timeout;
 }
 
 
 class SpawnTask : public ThreadPool::Task {
  public:
   SpawnTask(ThreadPool* pool, Monitor* sync, int todo, int total, int* done)
       : pool_(pool), sync_(sync), todo_(todo), total_(total), done_(done) {}
 
   virtual void Run() {
     todo_--;  // Subtract one for current task.
@@ skipping 36 matching lines @@
   {
     MonitorLocker ml(&sync);
     while (done < kTotalTasks) {
       ml.Wait();
     }
   }
   EXPECT_EQ(kTotalTasks, done);
 }
 
 }  // namespace dart