MediaRecorderHandler (video part) and unittests

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 "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 63 matching lines @@
 
   MOCK_METHOD4(OnEncodedVideo,
                void(const scoped_refptr<media::VideoFrame>& frame,
                     const base::StringPiece& encoded_data,
                     base::TimeTicks timestamp,
                     bool keyframe));
 
   void Encode(const scoped_refptr<media::VideoFrame>& frame,
               base::TimeTicks capture_time) {
     EXPECT_TRUE(message_loop_.IsCurrent());
-    video_track_recorder_->OnVideoFrame(frame, capture_time);
+    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.
   const base::MessageLoopForUI message_loop_;
-  ChildProcess child_process_;
+  const ChildProcess child_process_;
 
   // All members are non-const due to the series of initialize() calls needed.
   // |mock_source_| is owned by |blink_source_|, |track_| by |blink_track_|.
   MockMediaStreamVideoSource* mock_source_;
   blink::WebMediaStreamSource blink_source_;
   MediaStreamVideoTrack* track_;
   blink::WebMediaStreamTrack blink_track_;
 
   scoped_ptr<VideoTrackRecorder> video_track_recorder_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoTrackRecorderTest);
 };
 
+// Construct and destruct all objects, in particular |video_track_recorder_| and
+// its inner object(s). This is a non trivial sequence.
+TEST_F(VideoTrackRecorderTest, ConstructAndDestruct) {}
+
 // Creates the encoder and encodes 2 frames of the same size; the encoder should
 // be initialised and produce a keyframe, then a non-keyframe. Finally a frame
 // of larger size is sent and is expected to be encoded as a keyframe.
 TEST_F(VideoTrackRecorderTest, VideoEncoding) {
   // |frame_size| cannot be arbitrarily small, should be reasonable.
   const gfx::Size frame_size(160, 80);
   const scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::CreateBlackFrame(frame_size);
   const double kFrameRate = 60.0f;
   video_frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
@@ skipping 36 matching lines @@
   EXPECT_EQ(first_frame_encoded_data.size(), kFirstEncodedDataSize);
   const size_t kSecondEncodedDataSize = 32;
   EXPECT_EQ(second_frame_encoded_data.size(), kSecondEncodedDataSize);
   const size_t kThirdEncodedDataSize = 57;
   EXPECT_EQ(third_frame_encoded_data.size(), kThirdEncodedDataSize);
 
   Mock::VerifyAndClearExpectations(this);
 }
 
 }  // namespace content