MediaRecorder: handle libwebm::Segment::AddFrame() errors and wire up to Blink

content/renderer/media/media_recorder_handler_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 <stddef.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 98 matching lines @@
   }
 
   void AddTracks() {
     // Avoid issues with non-parameterized tests by calling this outside of ctr.
     if (GetParam().has_video)
       registry_.AddVideoTrack(kTestVideoTrackId);
     if (GetParam().has_audio)
       registry_.AddAudioTrack(kTestAudioTrackId);
   }
 
+  void ForceOneErrorInWebmMuxer() {
+    media_recorder_handler_->webm_muxer_->ForceOneLibWebmErrorForTesting();
+  }
+
   std::unique_ptr<media::AudioBus> NextAudioBus() {
     std::unique_ptr<media::AudioBus> bus(media::AudioBus::Create(
         kTestAudioChannels,
         kTestAudioSampleRate * kTestAudioBufferDurationMs / 1000));
     audio_source_.OnMoreData(base::TimeDelta(), base::TimeTicks::Now(), 0,
                              bus.get());
     return bus;
   }
 
   // A ChildProcess and a MessageLoopForUI are both needed to fool the Tracks
@@ skipping 203 matching lines @@
     run_loop.Run();
   }
 
   media_recorder_handler_->stop();
 
   // Expect a last call on destruction, with size 0 and |lastInSlice| true.
   EXPECT_CALL(*this, writeData(nullptr, 0, true, _)).Times(1);
   media_recorder_handler_.reset();
 }
 
+// Starts up recording and forces a WebmMuxer's libwebm error.
+TEST_P(MediaRecorderHandlerTest, WebmMuxerErrorWhileEncoding) {
+  // Video-only test: Audio would be very similar.
+  if (GetParam().has_audio)
+    return;
+
+  AddTracks();
+
+  const WebString mime_type(base::UTF8ToUTF16(GetParam().mime_type));
+  const WebString codecs(base::UTF8ToUTF16(GetParam().codecs));
+  EXPECT_TRUE(media_recorder_handler_->initialize(this, registry_.test_stream(),
+                                                  mime_type, codecs, 0, 0));
+  EXPECT_TRUE(media_recorder_handler_->start(0));
+
+  InSequence s;
+  const scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::CreateBlackFrame(gfx::Size(160, 80));
+
+  {
+    const size_t kEncodedSizeThreshold = 16;
+    base::RunLoop run_loop;
+    base::Closure quit_closure = run_loop.QuitClosure();
+    EXPECT_CALL(*this, writeData(_, _, _, _)).Times(AtLeast(1));
+    EXPECT_CALL(*this, writeData(_, Gt(kEncodedSizeThreshold), _, _))
+        .Times(1)
+        .WillOnce(RunClosure(quit_closure));
+
+    OnVideoFrameForTesting(video_frame);
+    run_loop.Run();
+  }
+
+  ForceOneErrorInWebmMuxer();
+
+  {
+    base::RunLoop run_loop;
+    base::Closure quit_closure = run_loop.QuitClosure();
+    EXPECT_CALL(*this, writeData(_, _, _, _)).Times(0);
+    EXPECT_CALL(*this, onError(_)).Times(1).WillOnce(RunClosure(quit_closure));
+
+    OnVideoFrameForTesting(video_frame);
+    run_loop.Run();
+  }
+
+
+  // Expect a last call on destruction, with size 0 and |lastInSlice| true.
+  EXPECT_CALL(*this, writeData(nullptr, 0, true, _)).Times(1);
+  media_recorder_handler_.reset();
+}
+
 }  // namespace content