cc: Use HighResNow as timebase if it is fast and reliable

cc/output/output_surface.cc

 // Copyright (c) 2013 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/output/output_surface.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 using std::set;
 using std::string;
 using std::vector;
 
 namespace {
 
 const size_t kGpuLatencyHistorySize = 60;
@@ skipping 50 matching lines @@
       check_for_retroactive_begin_impl_frame_pending_(false),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this),
       gpu_latency_history_(kGpuLatencyHistorySize) {}
 
 void OutputSurface::InitializeBeginImplFrameEmulation(
     base::SingleThreadTaskRunner* task_runner,
     bool throttle_frame_production,
     base::TimeDelta interval) {
   if (throttle_frame_production) {
-    frame_rate_controller_.reset(
-        new FrameRateController(
-            DelayBasedTimeSource::Create(interval, task_runner)));
+    scoped_refptr<DelayBasedTimeSource> time_source;
+    if (gfx::FrameTime::TimestampsAreHighRes())
+      time_source = DelayBasedTimeSourceHighRes::Create(interval, task_runner);
+    else
+      time_source = DelayBasedTimeSource::Create(interval, task_runner);
+    frame_rate_controller_.reset(new FrameRateController(time_source));
   } else {
     frame_rate_controller_.reset(new FrameRateController(task_runner));
   }
 
   frame_rate_controller_->SetClient(this);
   frame_rate_controller_->SetMaxSwapsPending(max_frames_pending_);
   frame_rate_controller_->SetDeadlineAdjustment(
       capabilities_.adjust_deadline_for_parent ?
           BeginFrameArgs::DefaultDeadlineAdjustment() : base::TimeDelta());
 
@@ skipping 82 matching lines @@
   base::MessageLoop::current()->PostTask(
      FROM_HERE,
      base::Bind(&OutputSurface::CheckForRetroactiveBeginImplFrame,
                 weak_ptr_factory_.GetWeakPtr()));
   check_for_retroactive_begin_impl_frame_pending_ = true;
 }
 
 void OutputSurface::CheckForRetroactiveBeginImplFrame() {
   TRACE_EVENT0("cc", "OutputSurface::CheckForRetroactiveBeginImplFrame");
   check_for_retroactive_begin_impl_frame_pending_ = false;
-  if (base::TimeTicks::Now() < RetroactiveBeginImplFrameDeadline())
+  if (gfx::FrameTime::Now() < RetroactiveBeginImplFrameDeadline())
     BeginImplFrame(skipped_begin_impl_frame_args_);
 }
 
 void OutputSurface::DidSwapBuffers() {
   pending_swap_buffers_++;
   TRACE_EVENT1("cc", "OutputSurface::DidSwapBuffers",
                "pending_swap_buffers_", pending_swap_buffers_);
   if (frame_rate_controller_)
     frame_rate_controller_->DidSwapBuffers();
   PostCheckForRetroactiveBeginImplFrame();
@@ skipping 278 matching lines @@
                "discard_backbuffer", discard_backbuffer);
   // Just ignore the memory manager when it says to set the limit to zero
   // bytes. This will happen when the memory manager thinks that the renderer
   // is not visible (which the renderer knows better).
   if (policy.bytes_limit_when_visible)
     client_->SetMemoryPolicy(policy);
   client_->SetDiscardBackBufferWhenNotVisible(discard_backbuffer);
 }
 
 }  // namespace cc