Release video frames earlier in MediaRecorder

content/renderer/media/video_track_recorder_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 "content/renderer/media/video_track_recorder.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 76 matching lines @@
   }
 
   ~VideoTrackRecorderTest() {
     blink_track_.reset();
     blink_source_.reset();
     video_track_recorder_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   MOCK_METHOD4(DoOnEncodedVideo,
-               void(const scoped_refptr<VideoFrame>& frame,
+               void(const media::WebmMuxer::VideoParameters& params,
                     std::string encoded_data,
                     base::TimeTicks timestamp,
                     bool keyframe));
-  void OnEncodedVideo(const scoped_refptr<VideoFrame>& video_frame,
+  void OnEncodedVideo(const media::WebmMuxer::VideoParameters& params,
                       std::unique_ptr<std::string> encoded_data,
                       base::TimeTicks timestamp,
                       bool is_key_frame) {
-    DoOnEncodedVideo(video_frame, *encoded_data, timestamp, is_key_frame);
+    DoOnEncodedVideo(params, *encoded_data, timestamp, is_key_frame);
   }
 
   void Encode(const scoped_refptr<VideoFrame>& frame,
               base::TimeTicks capture_time) {
     EXPECT_TRUE(message_loop_.IsCurrent());
     video_track_recorder_->OnVideoFrameForTesting(frame, capture_time);
   }
 
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
   // and Sources below into believing they are on the right threads.
@@ skipping 25 matching lines @@
   const gfx::Size& frame_size = testing::get<1>(GetParam());
   const scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateBlackFrame(frame_size);
   const double kFrameRate = 60.0f;
   video_frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                      kFrameRate);
 
   InSequence s;
   const base::TimeTicks timeticks_now = base::TimeTicks::Now();
   base::StringPiece first_frame_encoded_data;
-  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame, _, timeticks_now, true))
+  EXPECT_CALL(*this, DoOnEncodedVideo(_, _, timeticks_now, true))
       .Times(1)
       .WillOnce(SaveArg<1>(&first_frame_encoded_data));
   Encode(video_frame, timeticks_now);
 
   // Send another Video Frame.
   const base::TimeTicks timeticks_later = base::TimeTicks::Now();
   base::StringPiece second_frame_encoded_data;
-  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame, _, timeticks_later, false))
+  EXPECT_CALL(*this, DoOnEncodedVideo(_, _, timeticks_later, false))
       .Times(1)
       .WillOnce(SaveArg<1>(&second_frame_encoded_data));
   Encode(video_frame, timeticks_later);
 
   // Send another Video Frame and expect only an DoOnEncodedVideo() callback.
   const gfx::Size frame_size2(frame_size.width() + kTrackRecorderTestSizeDiff,
                               frame_size.height());
   const scoped_refptr<VideoFrame> video_frame2 =
       VideoFrame::CreateBlackFrame(frame_size2);
 
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
 
   base::StringPiece third_frame_encoded_data;
-  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame2, _, _, true))
+  EXPECT_CALL(*this, DoOnEncodedVideo(_, _, _, true))
       .Times(1)
       .WillOnce(DoAll(SaveArg<1>(&third_frame_encoded_data),
                 RunClosure(quit_closure)));
   Encode(video_frame2, base::TimeTicks::Now());
 
   run_loop.Run();
 
   const size_t kEncodedSizeThreshold = 14;
   EXPECT_GE(first_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(second_frame_encoded_data.size(), kEncodedSizeThreshold);
   EXPECT_GE(third_frame_encoded_data.size(), kEncodedSizeThreshold);
 
   Mock::VerifyAndClearExpectations(this);
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoTrackRecorderTest,
                         ::testing::Combine(ValuesIn(kTrackRecorderTestCodec),
                                            ValuesIn(kTrackRecorderTestSize)));
 
 }  // namespace content