Refactoring the way begin frame sources inside scheduler work.

cc/scheduler/frame_source_unittest.cc

+// Copyright 2011 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 <deque>
+
+#include "base/basictypes.h"
+#include "base/test/test_simple_task_runner.h"
+#include "cc/scheduler/frame_source.h"
+#include "cc/test/output_test_common.h"
+#include "cc/test/scheduler_test_common.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+/*
+base::TimeDelta Interval() {
+  return base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
+                                           60);
+}
+*/
+
+class FakeFrameSink : public FrameSink {
+ public:
+  void Expect(BeginFrameArgs args) { expected_.push_back(args); }
+
+  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {
+    ASSERT_GT(expected_.size(), 0U) << "Unexpected BeginFrame("
+                                    << ::testing::PrintToString(args)
+                                    << ") call!";
+    EXPECT_EQ(expected_[0], args);
+    expected_.pop_front();
+  }
+
+  virtual void Reset() {
+    EXPECT_EQ(expected_.size(), 0U) << "Missing " << expected_.size()
+                                    << " BeginFrame calls!";
+    expected_.clear();
+  }
+
+  virtual ~FakeFrameSink() { Reset(); }
+
+ private:
+  std::deque<BeginFrameArgs> expected_;
+};
+
+class FakeFrameSource : public BaseFrameSource {
+ public:
+  FakeFrameSource() : BaseFrameSource(0) {}
+
+  bool needs_begin_frame_;
+  base::TimeTicks timebase_;
+  base::TimeDelta interval_;
+
+  virtual void SetNeedsBeginFrame(bool needs_begin_frame) OVERRIDE {
+    needs_begin_frame_ = needs_begin_frame;
+  }
+  virtual void SetTimeBaseAndInterval(base::TimeTicks timebase,
+                                      base::TimeDelta interval) OVERRIDE {
+    timebase_ = timebase;
+    interval_ = interval;
+  }
+  virtual scoped_ptr<base::Value> FrameSourceAsValue() const OVERRIDE {
+    return make_scoped_ptr(base::Value::CreateNullValue());
+  }
+  virtual std::string FrameSourceType() const OVERRIDE {
+    return "FakeFrameSource";
+  }
+
+  void SendTestBeginFrame(const BeginFrameArgs& args) { SendBeginFrame(args); }
+};
+
+TEST(ProxyFrameSourceTest, Works) {
+  FakeFrameSink sink;
+  FakeFrameSource source;
+
+  // BeginFrame
+  sink.Expect(BeginFrameArgsCreate(100, 200, 300));
+  sink.Expect(BeginFrameArgsCreate(400, 600, 300));
+  ProxyFrameSource proxy(&sink, &source);
+  proxy.BeginFrame(BeginFrameArgsCreate(100, 200, 300));
+  proxy.BeginFrame(BeginFrameArgsCreate(400, 600, 300));
+
+  // SetNeedsBeginFrame
+  source.needs_begin_frame_ = false;
+  proxy.SetNeedsBeginFrame(true);
+  EXPECT_EQ(source.needs_begin_frame_, true);
+  proxy.SetNeedsBeginFrame(false);
+  EXPECT_EQ(source.needs_begin_frame_, false);
+
+  // SetTimeBaseAndInterval
+  source.timebase_ = base::TimeTicks();
+  source.interval_ = base::TimeDelta();
+  proxy.SetTimeBaseAndInterval(base::TimeTicks::FromInternalValue(123),
+                               base::TimeDelta::FromInternalValue(456));
+  EXPECT_EQ(source.timebase_.ToInternalValue(), 123);
+  EXPECT_EQ(source.interval_.ToInternalValue(), 456);
+}
+
+TEST(ThrottledFrameSource, Works) {
+  FakeFrameSink sink;
+  sink.Expect(BeginFrameArgsCreate(100, 200, 300));
+  sink.Expect(BeginFrameArgsCreate(700, 900, 300));
+
+  FakeFrameSource* fake_source = new FakeFrameSource();
+  ThrottledFrameSource source(&sink,
+                              scoped_ptr<FrameSource>(fake_source),
+                              base::TimeDelta::FromInternalValue(600));
+  fake_source->SendTestBeginFrame(BeginFrameArgsCreate(100, 200, 300));
+  fake_source->SendTestBeginFrame(BeginFrameArgsCreate(400, 600, 300));
+  fake_source->SendTestBeginFrame(BeginFrameArgsCreate(700, 900, 300));
+}
+
+TEST(BackToBackFrameSource, TickNotCalledWithTaskPosted) {
+  FakeFrameSink sink;
+
+  //  BackToBackFrameSource source();
+}
+
+TEST(SyntheticFrameSource, Works) {
+  FakeFrameSink sink;
+}
+
+TEST(DualFrameSource, Works) {
+  FakeFrameSink sink;
+
+  FakeFrameSource* fake_primary = new FakeFrameSource();
+  fake_primary->needs_begin_frame_ = false;
+  FakeFrameSource* fake_secondary = new FakeFrameSource();
+  fake_secondary->needs_begin_frame_ = false;
+
+  DualFrameSource source(&sink,
+                         scoped_ptr<FrameSource>(fake_primary),
+                         scoped_ptr<FrameSource>(fake_secondary));
+  source.SwitchSource(source.SourcePrimary());
+
+  // Check SetNeedsBeginFrame works
+  source.SetNeedsBeginFrame(true);
+  EXPECT_EQ(fake_primary->needs_begin_frame_, true);
+  EXPECT_EQ(fake_secondary->needs_begin_frame_, false);
+  source.SetNeedsBeginFrame(false);
+  EXPECT_EQ(fake_primary->needs_begin_frame_, false);
+  EXPECT_EQ(fake_secondary->needs_begin_frame_, false);
+
+  // Checking that switching the source makes SetNeedsBeginFrame on the
+  // subsources correctly.
+  source.SetNeedsBeginFrame(true);
+  source.SwitchSource(source.SourceSecondary());
+  EXPECT_EQ(fake_primary->needs_begin_frame_, false);
+  EXPECT_EQ(fake_secondary->needs_begin_frame_, true);
+  source.SwitchSource(source.SourcePrimary());
+  EXPECT_EQ(fake_primary->needs_begin_frame_, true);
+  EXPECT_EQ(fake_secondary->needs_begin_frame_, false);
+
+  sink.Reset();
+
+  // Check that BeginFrame calls end up at the sink
+  {
+    SCOPED_TRACE("First test");
+    sink.Expect(BeginFrameArgsCreate(100, 200, 300));
+    sink.Expect(BeginFrameArgsCreate(400, 600, 300));
+    fake_primary->SendTestBeginFrame(BeginFrameArgsCreate(100, 200, 300));
+    fake_secondary->SendTestBeginFrame(BeginFrameArgsCreate(400, 600, 300));
+    sink.Reset();
+  }
+
+  // Check that BeginFrames can't go backwards
+  {
+    SCOPED_TRACE("Backwards test");
+    sink.Expect(BeginFrameArgsCreate(400, 600, 300));
+    sink.Expect(BeginFrameArgsCreate(700, 900, 300));
+    sink.Expect(BeginFrameArgsCreate(1000, 1200, 300));
+    fake_primary->SendTestBeginFrame(BeginFrameArgsCreate(400, 600, 300));
+    fake_primary->SendTestBeginFrame(BeginFrameArgsCreate(700, 900, 300));
+    fake_secondary->SendTestBeginFrame(BeginFrameArgsCreate(699, 899, 300));
+    fake_primary->SendTestBeginFrame(BeginFrameArgsCreate(1000, 1200, 300));
+    sink.Reset();
+  }
+}
+
+}  // namespace
+}  // namespace cc