[cc] Add and plumb CFS::DidNotProduceFrame.

services/ui/ws/frame_generator_unittest.cc

 // Copyright 2017 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 "services/ui/ws/frame_generator.h"
 
 #include "base/macros.h"
 #include "cc/output/compositor_frame_sink.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/test/begin_frame_args_test.h"
@@ skipping 28 matching lines @@
   explicit TestClientBinding(
       cc::mojom::MojoCompositorFrameSinkClient* sink_client)
       : sink_client_(sink_client) {}
   ~TestClientBinding() override = default;
 
   // cc::mojom::MojoCompositorFrameSink implementation:
   void SubmitCompositorFrame(const cc::LocalSurfaceId& local_surface_id,
                              cc::CompositorFrame frame) override {
     ++frames_submitted_;
     last_frame_ = std::move(frame);
-    begin_frame_source_->DidFinishFrame(this,
-                                        last_frame_.metadata.begin_frame_ack);
+    last_begin_frame_ack_ = last_frame_.metadata.begin_frame_ack;
+  }
+
+  void DidNotProduceFrame(const cc::BeginFrameAck& ack) override {
+    last_begin_frame_ack_ = ack;
   }
 
   void SetNeedsBeginFrame(bool needs_begin_frame) override {
     if (needs_begin_frame == observing_begin_frames_)
       return;
 
     observing_begin_frames_ = needs_begin_frame;
     if (needs_begin_frame) {
       begin_frame_source_->AddObserver(this);
     } else
       begin_frame_source_->RemoveObserver(this);
   }
 
-  void BeginFrameDidNotSwap(const cc::BeginFrameAck& ack) override {
-    if (observing_begin_frames_)
-      begin_frame_source_->DidFinishFrame(this, ack);
-  }
-
   void EvictCurrentSurface() override {}
 
   // cc::BeginFrameObserver implementation.
   void OnBeginFrame(const cc::BeginFrameArgs& args) override {
     sink_client_->OnBeginFrame(args);
     last_begin_frame_args_ = args;
   }
 
   const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override {
     return last_begin_frame_args_;
   }
 
   void OnBeginFrameSourcePausedChanged(bool paused) override {}
 
   void SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) {
     begin_frame_source_ = begin_frame_source;
   }
 
   const cc::RenderPassList& last_render_pass_list() const {
     return last_frame_.render_pass_list;
   }
 
   const cc::CompositorFrameMetadata& last_metadata() const {
     return last_frame_.metadata;
   }
 
   int frames_submitted() const { return frames_submitted_; }
 
+  const cc::BeginFrameAck& last_begin_frame_ack() const {
+    return last_begin_frame_ack_;
+  }
+
  private:
   cc::mojom::MojoCompositorFrameSinkClient* sink_client_;
   cc::BeginFrameArgs last_begin_frame_args_;
   cc::CompositorFrame last_frame_;
   cc::BeginFrameSource* begin_frame_source_ = nullptr;
   bool observing_begin_frames_ = false;
   int frames_submitted_ = 0;
+  cc::BeginFrameAck last_begin_frame_ack_;
 };
 
 class FrameGeneratorTest : public testing::Test {
  public:
   FrameGeneratorTest() = default;
   ~FrameGeneratorTest() override = default;
 
   // testing::Test overrides:
   void SetUp() override {
     testing::Test::SetUp();
@@ skipping 28 matching lines @@
   }
 
   void IssueBeginFrame() {
     begin_frame_source_->TestOnBeginFrame(cc::CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, 0, next_sequence_number_));
     ++next_sequence_number_;
   }
 
   int NumberOfFramesReceived() const { return binding_->frames_submitted(); }
 
-  const cc::BeginFrameAck& LastBeginFrameAck() {
-    return begin_frame_source_->LastAckForObserver(binding_);
+  const cc::BeginFrameAck& LastBeginFrameAck() const {
+    return binding_->last_begin_frame_ack();
   }
 
   const cc::CompositorFrameMetadata& LastMetadata() const {
     return binding_->last_metadata();
   }
 
   const cc::RenderPassList& LastRenderPassList() const {
     return binding_->last_render_pass_list();
   }
 
@@ skipping 112 matching lines @@
   InitWithSurfaceInfo();
 
   frame_generator()->OnWindowDamaged();
   IssueBeginFrame();
   EXPECT_EQ(2, NumberOfFramesReceived());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui