[cc] Use base::TimeTicks in RenderStats

cc/raster_worker_pool.cc

 // Copyright 2012 The Chromium 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 "cc/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 20 matching lines @@
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
   picture_pile->Raster(&canvas, rect, contents_scale, stats);
 }
 
 void RunImageDecodeTask(skia::LazyPixelRef* pixel_ref, RenderingStats* stats) {
   TRACE_EVENT0("cc", "RunImageDecodeTask");
   base::TimeTicks decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   stats->totalDeferredImageDecodeCount++;
-  stats->totalDeferredImageDecodeTimeInSeconds +=
-      (base::TimeTicks::Now() - decode_begin_time).InSecondsF();
+  stats->totalDeferredImageDecodeTime +=
+      base::TimeTicks::Now() - decode_begin_time;
 }
 
 const char* kRasterThreadNamePrefix = "CompositorRaster";
 
 // Allow two pending raster tasks per thread. This keeps resource usage
 // low while making sure raster threads aren't unnecessarily idle.
 const int kNumPendingRasterTasksPerThread = 2;
 
 }  // namespace
 
 RasterWorkerPool::Thread::Task::Task(Thread* thread) : thread_(thread) {
   thread_->num_pending_tasks_++;
 }
 
 RasterWorkerPool::Thread::Task::~Task() {
-  thread_->rendering_stats_.totalRasterizeTimeInSeconds +=
-      rendering_stats_.totalRasterizeTimeInSeconds;
+  thread_->rendering_stats_.totalRasterizeTime +=
+      rendering_stats_.totalRasterizeTime;
   thread_->rendering_stats_.totalPixelsRasterized +=
       rendering_stats_.totalPixelsRasterized;
-  thread_->rendering_stats_.totalDeferredImageDecodeTimeInSeconds +=
-      rendering_stats_.totalDeferredImageDecodeTimeInSeconds;
+  thread_->rendering_stats_.totalDeferredImageDecodeTime +=
+      rendering_stats_.totalDeferredImageDecodeTime;
   thread_->rendering_stats_.totalDeferredImageDecodeCount +=
       rendering_stats_.totalDeferredImageDecodeCount;
 
   thread_->num_pending_tasks_--;
 }
 
 RasterWorkerPool::Thread::Thread(const std::string name)
     : base::Thread(name.c_str()),
       num_pending_tasks_(0) {
   Start();
@@ skipping 55 matching lines @@
   task->thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&RunImageDecodeTask, pixel_ref, &task->rendering_stats_),
       base::Bind(&RasterWorkerPool::OnTaskCompleted,
                  base::Unretained(this),
                  base::Unretained(task),
                  reply));
 }
 
 void RasterWorkerPool::GetRenderingStats(RenderingStats* stats) {
-  stats->totalRasterizeTimeInSeconds = 0;
+  stats->totalRasterizeTime = base::TimeDelta();
   stats->totalPixelsRasterized = 0;
   stats->totalDeferredImageDecodeCount = 0;
-  stats->totalDeferredImageDecodeTimeInSeconds = 0;
+  stats->totalDeferredImageDecodeTime = base::TimeDelta();
   for (ThreadVector::iterator it = raster_threads_.begin();
        it != raster_threads_.end(); ++it) {
     Thread* thread = *it;
-    stats->totalRasterizeTimeInSeconds +=
-        thread->rendering_stats().totalRasterizeTimeInSeconds;
+    stats->totalRasterizeTime +=
+        thread->rendering_stats().totalRasterizeTime;
     stats->totalPixelsRasterized +=
         thread->rendering_stats().totalPixelsRasterized;
     stats->totalDeferredImageDecodeCount +=
         thread->rendering_stats().totalDeferredImageDecodeCount;
-    stats->totalDeferredImageDecodeTimeInSeconds +=
-        thread->rendering_stats().totalDeferredImageDecodeTimeInSeconds;
+    stats->totalDeferredImageDecodeTime +=
+        thread->rendering_stats().totalDeferredImageDecodeTime;
   }
 }
 
 RasterWorkerPool::Thread::Task* RasterWorkerPool::CreateTask() {
   Thread* thread = raster_threads_.front();
   DCHECK(thread->num_pending_tasks() < kNumPendingRasterTasksPerThread);
 
   scoped_ptr<Thread::Task> task(new Thread::Task(thread));
   std::sort(raster_threads_.begin(), raster_threads_.end(),
             PendingTaskComparator());
@@ skipping 13 matching lines @@
 }
 
 void RasterWorkerPool::OnRasterTaskCompleted(
     Thread::Task* task,
     scoped_refptr<PicturePileImpl> picture_pile,
     const base::Closure& reply) {
   OnTaskCompleted(task, reply);
 }
 
 }  // namespace cc