cc: Test BeginMainFrame values come from BeginImplFrame.

cc/trees/layer_tree_host_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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 4603 matching lines @@
 
 class LayerTreeHostTestWillBeginImplFrameHasDidFinishImplFrame
     : public LayerTreeHostTest {
  public:
   enum { kExpectedNumImplFrames = 10 };
 
   LayerTreeHostTestWillBeginImplFrameHasDidFinishImplFrame()
       : will_begin_impl_frame_count_(0), did_finish_impl_frame_count_(0) {}
 
   void BeginTest() override {
-    // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
     EXPECT_EQ(will_begin_impl_frame_count_, did_finish_impl_frame_count_);
     EXPECT_FALSE(TestEnded());
     will_begin_impl_frame_count_++;
   }
 
@@ skipping 25 matching lines @@
   }
 
  private:
   int will_begin_impl_frame_count_;
   int did_finish_impl_frame_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestWillBeginImplFrameHasDidFinishImplFrame);
 
+::testing::AssertionResult AssertFrameTimeContained(
+    const char* haystack_expr,
+    const char* needle_expr,
+    const std::vector<BeginFrameArgs> haystack,
+    const BeginFrameArgs needle) {
+  auto failure = ::testing::AssertionFailure()
+                 << needle.frame_time << " (" << needle_expr
+                 << ") not found in " << haystack_expr;
+
+  if (haystack.size() == 0) {
+    failure << " which is empty.";
+  } else {
+    failure << " which contains:\n";
+    for (size_t i = 0; i < haystack.size(); i++) {
+      if (haystack[i].frame_time == needle.frame_time)
+        return ::testing::AssertionSuccess();
+      failure << "  [" << i << "]: " << haystack[i].frame_time << "\n";
+    }
+  }
+
+  return failure;
+}
+
+class LayerTreeHostTestBeginMainFrameTimeIsAlsoImplTime
+    : public LayerTreeHostTest {
+ public:
+  LayerTreeHostTestBeginMainFrameTimeIsAlsoImplTime()
+      : impl_frame_args_(), will_begin_impl_frame_count_(0) {}
+
+  void BeginTest() override {
+    // Kick off the test with a commit.
+    PostSetNeedsCommitToMainThread();
+  }
+
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
+                                  const BeginFrameArgs& args) override {
+    impl_frame_args_.push_back(args);
+
+    will_begin_impl_frame_count_++;
+    if (will_begin_impl_frame_count_ < 10)
+      PostSetNeedsCommitToMainThread();
+  }
+
+  void BeginMainFrame(const BeginFrameArgs& args) override {
+    ASSERT_GT(impl_frame_args_.size(), 0U)
+        << "BeginMainFrame called before BeginImplFrame called!";
+    EXPECT_PRED_FORMAT2(AssertFrameTimeContained, impl_frame_args_, args);
+  }
+
+  void SendBeginMainFrameNotExpectedSoon() override { EndTest(); }
+
+  void AfterTest() override {
+    EXPECT_GT(impl_frame_args_.size(), 0U);
+    EXPECT_GE(will_begin_impl_frame_count_, 10);
+  }
+
+ private:
+  std::vector<BeginFrameArgs> impl_frame_args_;
+  int will_begin_impl_frame_count_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestBeginMainFrameTimeIsAlsoImplTime);
+
 class LayerTreeHostTestSendBeginFramesToChildren : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSendBeginFramesToChildren()
       : begin_frame_sent_to_children_(false) {
   }
 
   void BeginTest() override {
     // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 1588 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDestroyWhileInitializingOutputSurface);
 
 }  // namespace
 }  // namespace cc