WebmMuxer-MediaRecorderHandler: thread hopping and data ownership

media/capture/webm_muxer.h

 // 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.
 
 #ifndef MEDIA_FILTERS_LIBWEBM_MUXER_H_
 #define MEDIA_FILTERS_LIBWEBM_MUXER_H_
 
 #include <set>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_piece.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "media/base/media_export.h"
 #include "third_party/libwebm/source/mkvmuxer.hpp"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 class VideoFrame;
 
 // Adapter class to manage a WebM container [1], a simplified version of a
 // Matroska container [2], composed of an EBML header, and a single Segment
 // including at least a Track Section and a number of SimpleBlocks each
 // containing a single encoded video frame. WebM container has no Trailer.
 // Clients will push encoded VPx video frames one by one via the
 // OnEncodedVideo(). libwebm will eventually ping the WriteDataCB passed on
 // contructor with the wrapped encoded data.
 // WebmMuxer is created/destroyed on a thread, usually the Main Render thread,
 // and receives OnEncodedVideo()s on another thread, usually Render IO.
+// WebmMuxer is ref counted to avoid races between dtor and eventual encoded
+// frame(s) in flight.
 // [1] http://www.webmproject.org/docs/container/
 // [2] http://www.matroska.org/technical/specs/index.html
 // TODO(mcasas): Add support for Audio muxing.
-class MEDIA_EXPORT WebmMuxer : public NON_EXPORTED_BASE(mkvmuxer::IMkvWriter) {
+class MEDIA_EXPORT WebmMuxer : public NON_EXPORTED_BASE(mkvmuxer::IMkvWriter)
+                             , public base::RefCountedThreadSafe<WebmMuxer> {
  public:
   // Callback to be called when WebmMuxer is ready to write a chunk of data,
   // either any file header or a SingleBlock. The chunk is described as a byte
   // array and a byte length.
   using WriteDataCB = base::Callback<void(const base::StringPiece&)>;
 
-  explicit WebmMuxer(const WriteDataCB& write_data_callback);
-  ~WebmMuxer() override;
+  static void FinalizeSegment(scoped_ptr<mkvmuxer::Segment> segment);

[ajose, 2015/09/17 21:35:27]

Can this be below the ctr? 

https://engdoc.corp.google.com/eng/doc/devguide/cpp/styleguide.shtml?cl=head#...

+
+  WebmMuxer(const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+            const WriteDataCB& write_data_callback);
 
   // Adds a |video_frame| with |encoded_data.data()| to WebM Segment.
   // TODO(mcasas): Revisit how |encoded_data| is passed once the whole recording
   // chain is setup (http://crbug.com/262211).
   void OnEncodedVideo(const scoped_refptr<VideoFrame>& video_frame,
                       const base::StringPiece& encoded_data,
                       base::TimeTicks timestamp,
                       bool is_key_frame);
 
  private:
+  friend class base::RefCountedThreadSafe<WebmMuxer>;
   friend class WebmMuxerTest;
+  ~WebmMuxer() override;
 
   // Creates and adds a new video track. Called upon receiving the first
   // frame of a given Track, adds |frame_size| and |frame_rate| to the Segment
   // info, although individual frames passed to OnEncodedVideo() can have any
   // frame size.
   void AddVideoTrack(const gfx::Size& frame_size, double frame_rate);
 
   // IMkvWriter interface.
   mkvmuxer::int32 Write(const void* buf, mkvmuxer::uint32 len) override;
   mkvmuxer::int64 Position() const override;
   mkvmuxer::int32 Position(mkvmuxer::int64 position) override;
   bool Seekable() const override;
   void ElementStartNotify(mkvmuxer::uint64 element_id,
                           mkvmuxer::int64 position) override;
 
+  // Used to shutdown properly on the same thread we were created.
+  const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
   // Used to DCHECK that we are called on the correct thread (usually IO)
   base::ThreadChecker thread_checker_;
 
   // A caller-side identifier to interact with |segment_|, initialised upon
   // first frame arrival by AddVideoTrack().
   uint64_t track_index_;
 
   // Origin of times for frame timestamps.
   base::TimeTicks first_frame_timestamp_;
 
   // Callback to dump written data as being called by libwebm.
   const WriteDataCB write_data_callback_;
 
   // Rolling counter of the position in bytes of the written goo.
   base::CheckedNumeric<mkvmuxer::int64> position_;
 
   // The MkvMuxer active element.
-  mkvmuxer::Segment segment_;
+  scoped_ptr<mkvmuxer::Segment> segment_;
 
   DISALLOW_COPY_AND_ASSIGN(WebmMuxer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_LIBWEBM_MUXER_H_