WebmMuxer-MediaRecorderHandler: thread hopping and data ownership

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 19 matching lines @@
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 // Dummy interface class to be able to MOCK its methods.
 class EncodedVideoHandlerInterface {
  public:
   virtual void OnEncodedVideo(
                    const scoped_refptr<media::VideoFrame>& video_frame,
-                   const base::StringPiece& encoded_data,
+                   scoped_ptr<std::string> encoded_data,
                    base::TimeTicks timestamp,
                    bool is_key_frame) = 0;
   virtual ~EncodedVideoHandlerInterface() {}
 };
 
 class VideoTrackRecorderTest : public testing::Test,
                                public EncodedVideoHandlerInterface {
  public:
   VideoTrackRecorderTest()
       : mock_source_(new MockMediaStreamVideoSource(false)) {
@@ skipping 14 matching lines @@
     video_track_recorder_.reset(new VideoTrackRecorder(
         blink_track_,
         base::Bind(&VideoTrackRecorderTest::OnEncodedVideo,
                    base::Unretained(this))));
 
     // Paranoia checks.
     EXPECT_EQ(blink_track_.source().extraData(), blink_source_.extraData());
     EXPECT_TRUE(message_loop_.IsCurrent());
   }
 
-  MOCK_METHOD4(OnEncodedVideo,
+  MOCK_METHOD4(DoOnEncodedVideo,
                void(const scoped_refptr<media::VideoFrame>& frame,
-                    const base::StringPiece& encoded_data,
+                    std::string encoded_data,
                     base::TimeTicks timestamp,
                     bool keyframe));
+  void OnEncodedVideo(
+                   const scoped_refptr<media::VideoFrame>& video_frame,
+                   scoped_ptr<std::string> encoded_data,
+                   base::TimeTicks timestamp,
+                   bool is_key_frame) override {
+    DoOnEncodedVideo(video_frame, *encoded_data, timestamp, is_key_frame);
+  }
 
   void Encode(const scoped_refptr<media::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.
   const base::MessageLoopForUI message_loop_;
@@ skipping 24 matching lines @@
   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);
 
   InSequence s;
   const base::TimeTicks timeticks_now = base::TimeTicks::Now();
   base::StringPiece first_frame_encoded_data;
-  EXPECT_CALL(*this, OnEncodedVideo(video_frame, _, timeticks_now, true))
+  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame, _, 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, OnEncodedVideo(video_frame, _, timeticks_later, false))
+  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame, _, 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 OnEncodedVideo() callback.
+  // Send another Video Frame and expect only an DoOnEncodedVideo() callback.
   const gfx::Size frame_size2(180, 80);
   const scoped_refptr<media::VideoFrame> video_frame2 =
       media::VideoFrame::CreateBlackFrame(frame_size2);
 
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
 
   base::StringPiece third_frame_encoded_data;
-  EXPECT_CALL(*this, OnEncodedVideo(video_frame2, _, _, true))
+  EXPECT_CALL(*this, DoOnEncodedVideo(video_frame2, _, _, 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 kFirstEncodedDataSize = 52;
   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