[cc] Set BeginFrame sequence numbers on CompositorFrames from Scheduler.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 6998 matching lines @@
     EXPECT_EQ(21u, frame.resource_list.size());
 
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
+class LayerTreeHostTestBeginFrameSequenceNumbers : public LayerTreeHostTest {
+ protected:
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
+                                  const BeginFrameArgs& args) override {
+    if (current_begin_frame_args_.IsValid()) {

[brianderson, 2017/02/24 01:08:36]

This if condition probably isn't needed.

[Eric Seckler, 2017/02/27 11:50:32]

Done.

+      // We've received a second BeginFrame, stop blocking activation.
+      impl->BlockNotifyReadyToActivateForTesting(false);
+    }
+
+    EXPECT_TRUE(args.IsValid());
+    current_begin_frame_args_ = args;
+  }
+
+  void WillBeginMainFrame() override {
+    // Request another commit but defer it indefinitely. That way, the current
+    // commit's latest_confirmed_sequence_number should stay at the first
+    // BeginFrame's sequence number.
+    layer_tree_host()->SetDeferCommits(true);

[brianderson, 2017/02/24 01:08:37]

I think you can avoid this if you use the BeginCommitOnThread hook, which is
only called while the Main and Impl threads are "locked" to copy the
begin_main_frame_args to the impl-side if it hasn't already been copied.

[Eric Seckler, 2017/02/27 11:50:32]

Not entirely sure whether I understood this correctly. I'm now requesting
another commit in BeginCommitOnThread, but still setting begin_main_frame_args
in BeginMainFrame. No need for deferring commits anymore, it seems :)

+    PostSetNeedsCommitToMainThread();
+  }
+
+  void BeginMainFrame(const BeginFrameArgs& args) override {
+    EXPECT_FALSE(current_begin_main_frame_args_.IsValid());
+    EXPECT_TRUE(args.IsValid());
+    current_begin_main_frame_args_ = args;
+  }
+
+  void WillCommitCompleteOnThread(LayerTreeHostImpl* impl) override {
+    // Defer current commit's activation until second BeginFrame.
+    impl->BlockNotifyReadyToActivateForTesting(true);
+  }
+
+  DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* impl,
+                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   DrawResult draw_result) override {
+    // We should only draw in second BeginFrame.
+    EXPECT_TRUE(current_begin_main_frame_args_.IsValid());
+    EXPECT_LT(current_begin_main_frame_args_.sequence_number,
+              current_begin_frame_args_.sequence_number);
+    frame_data_ = frame_data;
+    return draw_result;
+  }
+
+  void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
+    EXPECT_TRUE(frame_data_);
+    EXPECT_EQ(current_begin_frame_args_.source_id,
+              frame_data_->begin_frame_source_id);
+    EXPECT_EQ(current_begin_frame_args_.sequence_number,
+              frame_data_->begin_frame_sequence_number);
+    EXPECT_EQ(current_begin_main_frame_args_.sequence_number,
+              frame_data_->latest_confirmed_begin_frame_sequence_number);
+  }
+
+  void DisplayReceivedCompositorFrameOnThread(
+      const CompositorFrame& frame) override {
+    compositor_frame_submitted_ = true;
+    EXPECT_EQ(current_begin_frame_args_.source_id,
+              frame.metadata.begin_frame_source_id);
+    EXPECT_EQ(current_begin_frame_args_.sequence_number,
+              frame.metadata.begin_frame_sequence_number);
+    EXPECT_EQ(current_begin_main_frame_args_.sequence_number,
+              frame.metadata.latest_confirmed_begin_frame_sequence_number);
+    EndTest();
+  }
+
+  void AfterTest() override { EXPECT_TRUE(compositor_frame_submitted_); }
+
+ private:
+  bool compositor_frame_submitted_;
+  BeginFrameArgs current_begin_frame_args_;
+  BeginFrameArgs current_begin_main_frame_args_;
+  LayerTreeHostImpl::FrameData* frame_data_;
+};
+
+MULTI_THREAD_BLOCKNOTIFY_TEST_F(LayerTreeHostTestBeginFrameSequenceNumbers);
+
 }  // namespace
 }  // namespace cc