cc: Adding BeginFrameTracker object and removing Now() from LTHI.

cc/scheduler/begin_frame_tracker.cc

+// Copyright 2014 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/scheduler/begin_frame_tracker.h"
+
+namespace cc {
+
+BeginFrameTracker::BeginFrameTracker(const tracked_objects::Location& location)
+    : location_(location),
+      location_string_(location.ToString()),
+      current_updated_at_(),
+      current_args_(),
+      current_finished_at_(base::TimeTicks::FromInternalValue(-1)) {
+}
+
+BeginFrameTracker::~BeginFrameTracker() {
+}
+
+void BeginFrameTracker::Start(BeginFrameArgs new_args) {
+  // Trace the frame time being passed between BeginFrameTrackers.
+  TRACE_EVENT_FLOW_STEP0(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), "BeginFrameArgs",
+      new_args.frame_time.ToInternalValue(), location_string_);
+
+  // Trace this specific begin frame tracker Start/Finish times.
+  TRACE_EVENT_ASYNC_BEGIN2(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
+      location_string_.c_str(), new_args.frame_time.ToInternalValue(),
+      "new args", new_args.AsValue(), "current args", current_args_.AsValue());
+
+  // Check the new BeginFrameArgs are valid and monotonically increasing.
+  DCHECK(new_args.IsValid());
+  DCHECK_LE(current_args_.frame_time, new_args.frame_time);
+
+  DCHECK(HasFinished())
+      << "Tried to start a new frame before finishing an existing frame.";
+  current_updated_at_ = base::TimeTicks::NowFromSystemTraceTime();

[brianderson, 2015/05/01 02:05:21]

This might be in a different timebase than base::FrameTime::Now(). Is that okay?

[mithro-old, 2015/05/01 03:27:56]

At the moment current_updated_at_ and current_finished_at_ are never compared to
anything, they are just used to track the point in time these events occurred
for tracing information (hence why they are using the tracing time).

It might cause an issue if we try and to the TODO below, but lets worry about it
when that happens.

+  current_args_ = new_args;
+  current_finished_at_ = base::TimeTicks();
+
+  // TODO(mithro): Add UMA tracking of delta between current_updated_at_ time

[brianderson, 2015/05/01 02:05:21]

I think we'll want to track this as part of LatencyInfo, which we can use for
telemetry, UMA, and scheduling decisions.

[mithro-old, 2015/05/01 03:27:56]

Lets figure that out after this patch lands.

+  // and the new_args.frame_time argument. This will give us how long after a
+  // BeginFrameArgs message was created before we started processing it.
+}
+
+const BeginFrameArgs& BeginFrameTracker::Current() const {
+  DCHECK(!HasFinished())
+      << "Tried to use BeginFrameArgs after marking the frame finished.";
+  DCHECK(current_args_.IsValid())
+      << "Tried to use BeginFrameArgs before starting a frame!";
+  return current_args_;
+}
+
+void BeginFrameTracker::Finish() {
+  DCHECK(!HasFinished()) << "Tried to finish an already finished frame";
+  current_finished_at_ = base::TimeTicks::NowFromSystemTraceTime();
+  TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
+                         location_string_.c_str(),
+                         current_args_.frame_time.ToInternalValue());
+}
+
+const BeginFrameArgs& BeginFrameTracker::Last() const {
+  DCHECK(current_args_.IsValid())
+      << "Tried to use last BeginFrameArgs before starting a frame!";
+  DCHECK(HasFinished())
+      << "Tried to use last BeginFrameArgs before the frame is finished.";
+  return current_args_;
+}
+
+base::TimeDelta BeginFrameTracker::Interval() const {
+  base::TimeDelta interval = current_args_.interval;
+  // Normal interval will be ~16ms, 200Hz (5ms) screens are the fastest
+  // easily available so anything less than that is likely an error.
+  if (interval < base::TimeDelta::FromMilliseconds(1)) {
+    interval = BeginFrameArgs::DefaultInterval();
+  }
+  return interval;
+}
+
+void BeginFrameTracker::AsValueInto(
+    base::TimeTicks now,
+    base::trace_event::TracedValue* state) const {
+  state->SetInteger("updated_at_us", current_updated_at_.ToInternalValue());
+  state->SetInteger("finished_at_us", current_finished_at_.ToInternalValue());
+  if (HasFinished()) {
+    state->SetString("state", "FINISHED");
+    state->BeginDictionary("current_args_");
+  } else {
+    state->SetString("state", "USING");
+    state->BeginDictionary("last_args_");
+  }
+  current_args_.AsValueInto(state);
+  state->EndDictionary();
+
+  base::TimeTicks frame_time = current_args_.frame_time;
+  base::TimeTicks deadline = current_args_.deadline;
+  base::TimeDelta interval = current_args_.interval;
+  state->BeginDictionary("major_timestamps_in_ms");
+  state->SetDouble("0_interval", interval.InMillisecondsF());
+  state->SetDouble("1_now_to_deadline", (deadline - now).InMillisecondsF());
+  state->SetDouble("2_frame_time_to_now", (now - frame_time).InMillisecondsF());
+  state->SetDouble("3_frame_time_to_deadline",
+                   (deadline - frame_time).InMillisecondsF());
+  state->SetDouble("4_now", (now - base::TimeTicks()).InMillisecondsF());
+  state->SetDouble("5_frame_time",
+                   (frame_time - base::TimeTicks()).InMillisecondsF());
+  state->SetDouble("6_deadline",
+                   (deadline - base::TimeTicks()).InMillisecondsF());
+  state->EndDictionary();
+}
+
+const BeginFrameArgs& BeginFrameTracker::DangerousMethodCurrentOrLast() const {
+  if (!HasFinished()) {
+    return Current();
+  } else {
+    return Last();
+  }
+}
+
+}  // namespace cc