Ignore sink start attempts when no frames are present.

media/base/null_video_sink_unittest.cc

 // Copyright 2015 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 <memory>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 80 matching lines @@
 
   // Verify that toggling background rendering mode issues the right bit to
   // each Render() call.
   sink->set_background_render(true);
 
   // A second call returning the same frame should not result in a new call to
   // FrameReceived().
   {
     SCOPED_TRACE("Waiting for second render call.");
     WaitableMessageLoopEvent event;
+    scoped_refptr<VideoFrame> test_frame_2 = CreateFrame(kInterval);
     EXPECT_CALL(*this, Render(_, _, true))
         .WillOnce(Return(test_frame))
-        .WillOnce(Return(nullptr));
+        .WillOnce(Return(test_frame_2));
     EXPECT_CALL(*this, FrameReceived(test_frame)).Times(0);
-    EXPECT_CALL(*this, FrameReceived(scoped_refptr<VideoFrame>()))
+    EXPECT_CALL(*this, FrameReceived(test_frame_2))
         .WillOnce(RunClosure(event.GetClosure()));
     event.RunAndWait();
   }
 
   {
     SCOPED_TRACE("Waiting for stop event.");
     WaitableMessageLoopEvent event;
     sink->set_stop_cb(event.GetClosure());
     sink->Stop();
     event.RunAndWait();
   }
 }
 
 TEST_F(NullVideoSinkTest, ClocklessFunctionality) {
   // Construct the sink with a huge interval, it should still complete quickly.
   const base::TimeDelta interval = base::TimeDelta::FromSeconds(10);
   std::unique_ptr<NullVideoSink> sink = ConstructSink(true, interval);
 
   scoped_refptr<VideoFrame> test_frame = CreateFrame(base::TimeDelta());
+  scoped_refptr<VideoFrame> test_frame_2 = CreateFrame(interval);
   sink->Start(this);
 
   EXPECT_CALL(*this, FrameReceived(test_frame)).Times(1);
-  EXPECT_CALL(*this, FrameReceived(scoped_refptr<VideoFrame>())).Times(1);
+  EXPECT_CALL(*this, FrameReceived(test_frame_2)).Times(1);
 
   const int kTestRuns = 6;
   const base::TimeTicks now = base::TimeTicks::Now();
   const base::TimeTicks current_time = tick_clock_.NowTicks();
 
   SCOPED_TRACE("Waiting for multiple render callbacks");
   WaitableMessageLoopEvent event;
   for (int i = 0; i < kTestRuns; ++i) {
     if (i < kTestRuns - 1) {
       EXPECT_CALL(*this, Render(current_time + i * interval,
                                 current_time + (i + 1) * interval, false))
           .WillOnce(Return(test_frame));
     } else {
       EXPECT_CALL(*this, Render(current_time + i * interval,
                                 current_time + (i + 1) * interval, false))
-          .WillOnce(DoAll(RunClosure(event.GetClosure()), Return(nullptr)));
+          .WillOnce(
+              DoAll(RunClosure(event.GetClosure()), Return(test_frame_2)));
     }
   }
   event.RunAndWait();
   ASSERT_LT(base::TimeTicks::Now() - now, kTestRuns * interval);
   sink->Stop();
 }
 
 }  // namespace media