[ui/ws] Acknowledge BeginFrames in FrameGenerator + add tests.

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.cc"
@@ skipping 69 matching lines @@
 
   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 {
-    external_begin_frame_source_->DidFinishFrame(this, ack);
+    begin_frame_source_->DidFinishFrame(this, ack);
   }
 
   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();
   }
@@ skipping 67 matching lines @@
         BEGINFRAME_FROM_HERE, 0, next_sequence_number_));
     ++next_sequence_number_;
   }
 
   FrameGenerator* frame_generator() { return frame_generator_.get(); }
 
   const cc::CompositorFrameMetadata& LastMetadata() {
     return compositor_frame_sink_->last_metadata();
   }
 
+  const cc::BeginFrameAck& LastBeginFrameAckFromFrameGenerator() {

[Fady Samuel, 2017/03/20 18:33:13]

nit: FromFrameGenerator is a bit redundant given this is a framegenerator
unittest.

[Eric Seckler, 2017/03/21 16:26:04]

Done.

+    return begin_frame_source_->LastAckForObserver(compositor_frame_sink_);
+  }
+
+  ServerWindow* root_window() { return root_window_.get(); }
+
  private:
   FakeCompositorFrameSink* compositor_frame_sink_ = nullptr;
   std::unique_ptr<cc::FakeExternalBeginFrameSource> begin_frame_source_;
   std::unique_ptr<TestFrameGeneratorDelegate> delegate_;
   std::unique_ptr<TestServerWindowDelegate> server_window_delegate_;
   std::unique_ptr<ServerWindow> root_window_;
   std::unique_ptr<FrameGenerator> frame_generator_;
   int next_sequence_number_ = 1;
 
   DISALLOW_COPY_AND_ASSIGN(FrameGeneratorTest);
 };
 
 TEST_F(FrameGeneratorTest, OnSurfaceCreated) {
   EXPECT_EQ(0, NumberOfFramesReceived());
 
   // FrameGenerator does not request BeginFrames upon creation.
   IssueBeginFrame();
   EXPECT_EQ(0, NumberOfFramesReceived());
+  EXPECT_EQ(cc::BeginFrameAck(), LastBeginFrameAckFromFrameGenerator());
 
   const cc::SurfaceId kArbitrarySurfaceId(
       cc::FrameSinkId(1, 1),
       cc::LocalSurfaceId(1, base::UnguessableToken::Create()));
   const cc::SurfaceInfo kArbitrarySurfaceInfo(kArbitrarySurfaceId, 1.0f,
                                               gfx::Size(100, 100));
   frame_generator()->OnSurfaceCreated(kArbitrarySurfaceInfo);
   EXPECT_EQ(0, NumberOfFramesReceived());
 
   IssueBeginFrame();
   EXPECT_EQ(1, NumberOfFramesReceived());
 
   // Verify that the CompositorFrame refers to the window manager's surface via
   // referenced_surfaces.
   const cc::CompositorFrameMetadata& last_metadata = LastMetadata();
   const std::vector<cc::SurfaceId>& referenced_surfaces =
       last_metadata.referenced_surfaces;
   EXPECT_EQ(1lu, referenced_surfaces.size());
   EXPECT_EQ(kArbitrarySurfaceId, referenced_surfaces.front());
 
+  cc::BeginFrameAck expected_ack(0, 2, 2, 0, true);
+  EXPECT_EQ(expected_ack, LastBeginFrameAckFromFrameGenerator());
+  EXPECT_EQ(expected_ack, last_metadata.begin_frame_ack);
+
   // FrameGenerator stops requesting BeginFrames after submitting a
   // CompositorFrame.
   IssueBeginFrame();
   EXPECT_EQ(1, NumberOfFramesReceived());
+  EXPECT_EQ(cc::BeginFrameAck(0, 2, 2, 0, true),
+            LastBeginFrameAckFromFrameGenerator());
+}
+
+TEST_F(FrameGeneratorTest, BeginFrameWhileInvisible) {
+  EXPECT_EQ(0, NumberOfFramesReceived());
+
+  // A valid SurfaceInfo is required for BeginFrame processing.
+  const cc::SurfaceId kArbitrarySurfaceId(
+      cc::FrameSinkId(1, 1),
+      cc::LocalSurfaceId(1, base::UnguessableToken::Create()));
+  const cc::SurfaceInfo kArbitrarySurfaceInfo(kArbitrarySurfaceId, 1.0f,
+                                              gfx::Size(100, 100));
+  frame_generator()->OnSurfaceCreated(kArbitrarySurfaceInfo);
+  EXPECT_EQ(0, NumberOfFramesReceived());
+
+  // No frames are produced while invisible but in need of BeginFrames.
+  root_window()->SetVisible(false);
+  IssueBeginFrame();
+  EXPECT_EQ(0, NumberOfFramesReceived());
+  EXPECT_EQ(cc::BeginFrameAck(0, 1, 1, 0, false),
+            LastBeginFrameAckFromFrameGenerator());
+
+  // When visible again, frame is produced.
+  root_window()->SetVisible(true);
+  IssueBeginFrame();
+  EXPECT_EQ(1, NumberOfFramesReceived());
+  cc::BeginFrameAck expected_ack(0, 2, 2, 0, true);
+  EXPECT_EQ(expected_ack, LastBeginFrameAckFromFrameGenerator());
+  EXPECT_EQ(expected_ack, LastMetadata().begin_frame_ack);
 }
 
 TEST_F(FrameGeneratorTest, SetDeviceScaleFactor) {
   EXPECT_EQ(0, NumberOfFramesReceived());
   const cc::SurfaceId kArbitrarySurfaceId(
       cc::FrameSinkId(1, 1),
       cc::LocalSurfaceId(1, base::UnguessableToken::Create()));
   const cc::SurfaceInfo kArbitrarySurfaceInfo(kArbitrarySurfaceId, 1.0f,
                                               gfx::Size(100, 100));
   constexpr float kDefaultScaleFactor = 1.0f;
@@ skipping 19 matching lines @@
   frame_generator()->SetDeviceScaleFactor(kArbitraryScaleFactor);
   IssueBeginFrame();
   EXPECT_EQ(2, NumberOfFramesReceived());
   const cc::CompositorFrameMetadata& second_last_metadata = LastMetadata();
   EXPECT_EQ(kArbitraryScaleFactor, second_last_metadata.device_scale_factor);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui