WebmMuxer-MediaRecorderHandler: thread hopping and data ownership

media/capture/webm_muxer_unittest.cc

Index: media/capture/webm_muxer_unittest.cc
diff --git a/media/capture/webm_muxer_unittest.cc b/media/capture/webm_muxer_unittest.cc
index bde9b4fb49a6d398240d17bb34f220f09bd84b48..5f69d8f618efdf9354a89ff1c259dbd23781e0f7 100644
--- a/media/capture/webm_muxer_unittest.cc
+++ b/media/capture/webm_muxer_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/test/test_simple_task_runner.h"
 #include "media/base/video_frame.h"
 #include "media/capture/webm_muxer.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -19,46 +20,45 @@ using ::testing::WithArgs;
 
 namespace media {
 
-// Dummy interface class to be able to MOCK its only function below.
-class EventHandlerInterface {
- public:
-  virtual void WriteCallback(const base::StringPiece& encoded_data) = 0;
-  virtual ~EventHandlerInterface() {}
-};
-
-class WebmMuxerTest : public testing::Test, public EventHandlerInterface {
+class WebmMuxerTest : public testing::Test {
  public:
   WebmMuxerTest()
-      : webm_muxer_(base::Bind(&WebmMuxerTest::WriteCallback,
-                               base::Unretained(this))),
+      : test_task_runner_(new base::TestSimpleTaskRunner()),
+        webm_muxer_(new WebmMuxer(test_task_runner_,
+                                  base::Bind(&WebmMuxerTest::WriteData,
+                                             base::Unretained(this)))),
         last_encoded_length_(0),
         accumulated_position_(0) {
-    EXPECT_EQ(webm_muxer_.Position(), 0);
+    EXPECT_EQ(webm_muxer_->Position(), 0);
     const mkvmuxer::int64 kRandomNewPosition = 333;
-    EXPECT_EQ(webm_muxer_.Position(kRandomNewPosition), -1);
-    EXPECT_FALSE(webm_muxer_.Seekable());
+    EXPECT_EQ(webm_muxer_->Position(kRandomNewPosition), -1);
+    EXPECT_FALSE(webm_muxer_->Seekable());
   }
 
-  MOCK_METHOD1(WriteCallback, void(const base::StringPiece&));
+  MOCK_METHOD1(WriteCallback, void(const std::string&));
+  void WriteData(scoped_ptr<std::string> data) {
+    WriteCallback(*data);
+  }
 
-  void SaveEncodedDataLen(const base::StringPiece& encoded_data) {
+  void SaveEncodedDataLen(const std::string& encoded_data) {
     last_encoded_length_ = encoded_data.size();
     accumulated_position_ += encoded_data.size();
   }
 
   mkvmuxer::int64 GetWebmMuxerPosition() const {
-    return webm_muxer_.Position();
+    return webm_muxer_->Position();
   }
 
   mkvmuxer::Segment::Mode GetWebmSegmentMode() const {
-    return webm_muxer_.segment_.mode();
+    return webm_muxer_->segment_->mode();
   }
 
   mkvmuxer::int32 WebmMuxerWrite(const void* buf, mkvmuxer::uint32 len) {
-    return webm_muxer_.Write(buf, len);
+    return webm_muxer_->Write(buf, len);
   }
 
-  WebmMuxer webm_muxer_;
+  const scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
+  scoped_refptr<WebmMuxer> webm_muxer_;
 
   size_t last_encoded_length_;
   int64_t accumulated_position_;
@@ -70,7 +70,7 @@ class WebmMuxerTest : public testing::Test, public EventHandlerInterface {
 // Checks that the WriteCallback is called with appropriate params when
 // WebmMuxer::Write() method is called.
 TEST_F(WebmMuxerTest, Write) {
-  const base::StringPiece encoded_data("abcdefghijklmnopqrstuvwxyz");
+  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
 
   EXPECT_CALL(*this, WriteCallback(encoded_data));
   WebmMuxerWrite(encoded_data.data(), encoded_data.size());
@@ -90,10 +90,10 @@ TEST_F(WebmMuxerTest, OnEncodedVideoTwoFrames) {
       .Times(AtLeast(1))
       .WillRepeatedly(WithArgs<0>(
           Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
-  webm_muxer_.OnEncodedVideo(video_frame,
-                             encoded_data,
-                             base::TimeTicks::Now(),
-                             false  /* keyframe */);
+  webm_muxer_->OnEncodedVideo(video_frame,
+                              encoded_data,
+                              base::TimeTicks::Now(),
+                              false  /* keyframe */);
 
   // First time around WriteCallback() is pinged a number of times to write the
   // Matroska header, but at the end it dumps |encoded_data|.
@@ -107,10 +107,10 @@ TEST_F(WebmMuxerTest, OnEncodedVideoTwoFrames) {
       .Times(AtLeast(1))
       .WillRepeatedly(WithArgs<0>(
           Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
-  webm_muxer_.OnEncodedVideo(video_frame,
-                             encoded_data,
-                             base::TimeTicks::Now(),
-                             false  /* keyframe */);
+  webm_muxer_->OnEncodedVideo(video_frame,
+                              encoded_data,
+                              base::TimeTicks::Now(),
+                              false  /* keyframe */);
 
   // The second time around the callbacks should include a SimpleBlock header,
   // namely the track index, a timestamp and a flags byte, for a total of 6B.