[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 47 matching lines @@
     return true;
   }
 
   void DetachFromClient() override {
     cc::CompositorFrameSink::DetachFromClient();
   }
 
   void SubmitCompositorFrame(cc::CompositorFrame frame) override {
     ++number_frames_received_;
     last_frame_ = std::move(frame);
+    last_begin_frame_ack_ = last_frame_.metadata.begin_frame_ack;
+  }
+
+  void BeginFrameDidNotProduceFrame(const cc::BeginFrameAck& ack) override {
+    last_begin_frame_ack_ = ack;
   }
 
   // cc::BeginFrameObserver implementation.
   void OnBeginFrame(const cc::BeginFrameArgs& args) override {
     external_begin_frame_source_->OnBeginFrame(args);
     last_begin_frame_args_ = args;
   }
 
   const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override {
     return last_begin_frame_args_;
   }
 
   void OnBeginFrameSourcePausedChanged(bool paused) override {}
 
   // cc::ExternalBeginFrameSourceClient implementation:
   void OnNeedsBeginFrames(bool needs_begin_frames) override {
     needs_begin_frames_ = needs_begin_frames;
     UpdateNeedsBeginFramesInternal();
   }
 
-  void OnDidFinishFrame(const cc::BeginFrameAck& ack) override {
-    begin_frame_source_->DidFinishFrame(this, ack);
-  }
+  void OnDidFinishFrame(const cc::BeginFrameAck& ack) override {}
 
   void SetBeginFrameSource(cc::BeginFrameSource* source) {
     if (begin_frame_source_ && observing_begin_frames_) {
       begin_frame_source_->RemoveObserver(this);
       observing_begin_frames_ = false;
     }
     begin_frame_source_ = source;
     UpdateNeedsBeginFramesInternal();
   }
 
   const cc::CompositorFrameMetadata& last_metadata() const {
     return last_frame_.metadata;
   }
 
   const cc::RenderPassList& last_render_pass_list() const {
     return last_frame_.render_pass_list;
   }
 
   int number_frames_received() { return number_frames_received_; }
 
+  const cc::BeginFrameAck& last_begin_frame_ack() {

[sunnyps, 2017/05/22 07:17:12]

nit: const method

[Eric Seckler, 2017/05/22 11:29:58]

Done.

+    return last_begin_frame_ack_;
+  }
+
  private:
   void UpdateNeedsBeginFramesInternal() {
     if (!begin_frame_source_)
       return;
 
     if (needs_begin_frames_ == observing_begin_frames_)
       return;
 
     observing_begin_frames_ = needs_begin_frames_;
     if (needs_begin_frames_) {
       begin_frame_source_->AddObserver(this);
     } else {
       begin_frame_source_->RemoveObserver(this);
     }
   }
 
   int number_frames_received_ = 0;
   std::unique_ptr<cc::ExternalBeginFrameSource> external_begin_frame_source_;
   cc::BeginFrameSource* begin_frame_source_ = nullptr;
   cc::BeginFrameArgs last_begin_frame_args_;
   bool observing_begin_frames_ = false;
   bool needs_begin_frames_ = false;
   cc::CompositorFrame last_frame_;
+  cc::BeginFrameAck last_begin_frame_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeCompositorFrameSink);
 };
 
 class FrameGeneratorTest : public testing::Test {
  public:
   FrameGeneratorTest() {}
   ~FrameGeneratorTest() override {}
 
   // testing::Test overrides:
@@ skipping 43 matching lines @@
 
   const cc::CompositorFrameMetadata& LastMetadata() const {
     return compositor_frame_sink_->last_metadata();
   }
 
   const cc::RenderPassList& LastRenderPassList() const {
     return compositor_frame_sink_->last_render_pass_list();
   }
 
   const cc::BeginFrameAck& LastBeginFrameAck() {
-    return begin_frame_source_->LastAckForObserver(compositor_frame_sink_);
+    return compositor_frame_sink_->last_begin_frame_ack();
   }
 
  private:
   FakeCompositorFrameSink* compositor_frame_sink_ = nullptr;
   std::unique_ptr<cc::FakeExternalBeginFrameSource> begin_frame_source_;
   std::unique_ptr<TestServerWindowDelegate> server_window_delegate_;
   std::unique_ptr<FrameGenerator> frame_generator_;
   int next_sequence_number_ = 1;
 
   DISALLOW_COPY_AND_ASSIGN(FrameGeneratorTest);
@@ skipping 135 matching lines @@
   InitWithSurfaceInfo();
 
   frame_generator()->OnWindowDamaged();
   IssueBeginFrame();
   EXPECT_EQ(2, NumberOfFramesReceived());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui