MediaStream: Adding VideoTrackRecorder class and unittests

content/renderer/media/video_track_recorder_unittest.cc

Index: content/renderer/media/video_track_recorder_unittest.cc
diff --git a/content/renderer/media/video_track_recorder_unittest.cc b/content/renderer/media/video_track_recorder_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..36db3488a3b6effcff10d266380bb6121b5300c9
--- /dev/null
+++ b/content/renderer/media/video_track_recorder_unittest.cc
@@ -0,0 +1,163 @@
+// 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"
+#include "base/strings/utf_string_conversions.h"
+#include "content/child/child_process.h"
+#include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/mock_media_stream_video_source.h"
+#include "content/renderer/media/video_track_recorder.h"
+#include "media/base/video_frame.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/web/WebHeap.h"
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::Return;
+using ::testing::SaveArg;
+using ::testing::InSequence;
+
+namespace content {
+
+// Dummy interface class to be able to MOCK its methods.
+class EncodedVideoHandlerInterface {
+ public:
+  virtual uint64_t OnFirstFrame(const gfx::Size& frame_size,
+                                double frame_rate) = 0;
+  virtual void OnEncodedVideo(uint64_t track_number,
+                              const base::StringPiece& encoded_data,
+                              base::TimeDelta timestamp,
+                              bool keyframe) = 0;
+  virtual ~EncodedVideoHandlerInterface() {}
+};
+
+class VideoTrackRecorderTest : public testing::Test,
+                               public EncodedVideoHandlerInterface {
+ public:
+  VideoTrackRecorderTest()
+      : child_process_(new ChildProcess()),
+        mock_source_(new MockMediaStreamVideoSource(false)) {
+    const blink::WebString webkit_track_id(base::UTF8ToUTF16("dummy"));
+    blink_source_.initialize(webkit_track_id,
+                             blink::WebMediaStreamSource::TypeVideo,
+                             webkit_track_id);
+    blink_source_.setExtraData(mock_source_);
+    blink_track_.initialize(blink_source_);
+
+    blink::WebMediaConstraints constraints;
+    constraints.initialize();
+    track_ = new MediaStreamVideoTrack(mock_source_, constraints,
+                                       MediaStreamSource::ConstraintsCallback(),
+                                       true /* enabled */);
+    blink_track_.setExtraData(track_);
+
+    video_track_recorder_.reset(new VideoTrackRecorder(
+        blink_track_,
+        base::Bind(&VideoTrackRecorderTest::OnFirstFrame,
+                   base::Unretained(this)),
+        base::Bind(&VideoTrackRecorderTest::OnEncodedVideo,
+                   base::Unretained(this))));
+
+    // Paranoia checks.
+    EXPECT_EQ(blink_track_.source().extraData(), blink_source_.extraData());
+    EXPECT_TRUE(message_loop_.IsCurrent());
+  }
+
+  MOCK_METHOD2(OnFirstFrame,
+               uint64_t(const gfx::Size& frame_size, double frame_rate));
+  MOCK_METHOD4(OnEncodedVideo,
+               void(uint64_t track_index,
+                    const base::StringPiece& encoded_data,
+                    base::TimeDelta timestamp,
+                    bool keyframe));
+
+  void Encode(const scoped_refptr<media::VideoFrame>& frame,
+              const base::TimeTicks& capture_time) {
+    EXPECT_TRUE(message_loop_.IsCurrent());
+    video_track_recorder_->StartFrameEncodeForTesting(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_;
+  const scoped_ptr<ChildProcess> child_process_;

[miu, 2015/08/04 04:06:30]

nit: Can this just be:

  ChildProcess child_process_;

[mcasas, 2015/08/11 09:35:17]

Done.

+
+  // 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);
+};
+
+// 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 a different 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,
+                                     kFrameRate);
+  const int kTrackIndex = 5;
+  const base::TimeDelta timedelta = base::TimeDelta::FromMilliseconds(0);
+
+  InSequence s;
+  EXPECT_CALL(*this, OnFirstFrame(frame_size, kFrameRate))
+      .Times(1)
+      .WillOnce(Return(kTrackIndex));
+  base::StringPiece first_frame_encoded_data;
+  EXPECT_CALL(*this, OnEncodedVideo(kTrackIndex, _, timedelta, true))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&first_frame_encoded_data));
+  Encode(video_frame, base::TimeTicks::Now());
+
+  // Send another Video Frame and expect only an OnEncodedVideo() callback.
+  EXPECT_CALL(*this, OnFirstFrame(frame_size, kFrameRate)).Times(0);
+  base::StringPiece second_frame_encoded_data;
+  EXPECT_CALL(*this, OnEncodedVideo(kTrackIndex, _, _, false))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&second_frame_encoded_data));
+  Encode(video_frame, base::TimeTicks::Now());
+
+  // Send another Video Frame and expect only an OnEncodedVideo() callback.
+  const gfx::Size frame_size2(140, 80);
+  const scoped_refptr<media::VideoFrame> video_frame2 =
+      media::VideoFrame::CreateBlackFrame(frame_size2);
+
+  EXPECT_CALL(*this, OnFirstFrame(frame_size2, kFrameRate)).Times(0);
+  base::StringPiece third_frame_encoded_data;
+  EXPECT_CALL(*this, OnEncodedVideo(kTrackIndex, _, _, true))
+      .Times(1)
+      .WillOnce(SaveArg<1>(&third_frame_encoded_data));
+  Encode(video_frame2, base::TimeTicks::Now());
+
+  child_process_->io_message_loop()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+
+  const size_t kFirstEncodedDataSize = 52;
+  EXPECT_EQ(first_frame_encoded_data.size(), kFirstEncodedDataSize);
+  const size_t kSecondEncodedDataSize = 33;
+  EXPECT_EQ(second_frame_encoded_data.size(), kSecondEncodedDataSize);
+  const size_t kThirdEncodedDataSize = 50;
+  EXPECT_EQ(third_frame_encoded_data.size(), kThirdEncodedDataSize);
+
+  Mock::VerifyAndClearExpectations(this);
+}
+
+}  // namespace content