cc: Add BeginFrameArgs

cc/output/begin_frame_args.cc

Index: cc/output/begin_frame_args.cc
diff --git a/cc/output/begin_frame_args.cc b/cc/output/begin_frame_args.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4daf3de4cea050935408b634ea81b049e5feb33d
--- /dev/null
+++ b/cc/output/begin_frame_args.cc
@@ -0,0 +1,53 @@
+// 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/begin_frame_args.h"
+
+namespace cc {
+
+BeginFrameArgs::BeginFrameArgs()
+  : frame_time_(base::TimeTicks()),
+    deadline_(base::TimeTicks()),
+    interval_(base::TimeDelta::FromMicroseconds(-1))
+{
+}
+
+BeginFrameArgs::BeginFrameArgs(base::TimeTicks frame_time,
+                               base::TimeTicks deadline,
+                               base::TimeDelta interval)
+  : frame_time_(frame_time),
+    deadline_(deadline),
+    interval_(interval)
+{}
+
+BeginFrameArgs BeginFrameArgs::Create(base::TimeTicks frame_time,
+                                      base::TimeTicks deadline,
+                                      base::TimeDelta interval) {
+  return BeginFrameArgs(frame_time, deadline, interval);
+}
+
+BeginFrameArgs BeginFrameArgs::CreateForSynchronousCompositor() {
+  // For WebView/SynchronousCompositor, we always want to draw immediately,
+  // so we set the deadline to 0 and guess that the interval is 16 milliseconds.
+  return BeginFrameArgs(base::TimeTicks::Now(),
+                        base::TimeTicks(),
+                        DefaultInterval());
+}
+
+BeginFrameArgs BeginFrameArgs::CreateForTesting() {
+  base::TimeTicks now = base::TimeTicks::Now();
+  return BeginFrameArgs(now,
+                        now + (DefaultInterval() / 2),
+                        DefaultInterval());
+}
+
+base::TimeDelta BeginFrameArgs::DefaultDeadlineAdjustment() {
+  return base::TimeDelta::FromMicroseconds(-8888);

[piman, 2013/06/14 22:53:46]

Can you explain to me what this means, and why it's a hard-coded value that
applies to all platforms, even the ones that haven't switched to the BeginFrame
flow yet?

Why half a frame? Does it mean that the renderer only has half a frame to
produce its output from the time it receives the BeginFrame?

[brianderson, 2013/06/14 23:32:12]

I will add a comment for what this is used for.

For platforms that support BeginFrame natively, the BeginFrame message from the
Browser will include a deadline that incorporates the expected draw time of the
Browser.

All other platforms use BeginFrame emulation as of
(https://chromiumcodereview.appspot.com/16833003/) by incorporating the
FrameRateController in the OutputSurface rather than the Scheduler.  In this
case, the deadline has to be set within the OutputSurface without a message from
a parent compositor. Currently, this is set to different values depending on
whether or not there is a parent compositor.

As a first stab, all code paths, whether they support BeginFrame natively or
not, will use this default deadline adjustment. Ali has a patch to actually
estimate the draw time in the threaded compositor that we can hook up when it
lands (https://chromiumcodereview.appspot.com/16574002).

In this patch, I chose half a frame arbitrarily since this doesn't affect
anything yet. It is a function so that we can potentially choose different
values for different platforms. In the worst case, we use some huge negative
number causing us to always be past the deadline, which will effectively revert
us to the current behavior of the scheduler.

An adjustment of half a frame means the renderer will have half a frame to
produce it's output if it wants to make *this* frame. If it does not, it can
still try to make the next frame.

+}
+
+base::TimeDelta BeginFrameArgs::DefaultInterval() {
+  return base::TimeDelta::FromMicroseconds(16666);
+}
+
+}  // namespace cc