MediaRecorder: support |timecode| and remove |m_ignoreMutedMedia|.

content/renderer/media/media_recorder_handler.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 "content/renderer/media/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 43 matching lines @@
       audio_bits_per_second_(0),
       codec_id_(VideoTrackRecorder::CodecId::VP8),
       recording_(false),
       client_(nullptr),
       weak_factory_(this) {}
 
 MediaRecorderHandler::~MediaRecorderHandler() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Send a |last_in_slice| to our |client_|.
   if (client_)
-    client_->writeData(nullptr, 0u, true);
+    client_->writeData(
+        nullptr, 0u, true,
+        (TimeTicks::Now() - TimeTicks::UnixEpoch()).InMillisecondsF());
 }
 
 bool MediaRecorderHandler::canSupportMimeType(
     const blink::WebString& web_type,
     const blink::WebString& web_codecs) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // An empty |web_type| means MediaRecorderHandler can choose its preferred
   // codecs.
   if (web_type.isEmpty())
     return true;
@@ skipping 197 matching lines @@
     const media::AudioParameters& params,
     std::unique_ptr<std::string> encoded_data,
     base::TimeTicks timestamp) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (webm_muxer_)
     webm_muxer_->OnEncodedAudio(params, std::move(encoded_data), timestamp);
 }
 
 void MediaRecorderHandler::WriteData(base::StringPiece data) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  const TimeTicks now = TimeTicks::Now();
   // Non-buffered mode does not need to check timestamps.
   if (timeslice_.is_zero()) {
-    client_->writeData(data.data(), data.length(), true  /* lastInSlice */);
+    client_->writeData(data.data(), data.length(), true /* lastInSlice */,
+                       (now - TimeTicks::UnixEpoch()).InMillisecondsF());
     return;
   }
 
-  const TimeTicks now = TimeTicks::Now();
   const bool last_in_slice = now > slice_origin_timestamp_ + timeslice_;
   DVLOG_IF(1, last_in_slice) << "Slice finished @ " << now;
   if (last_in_slice)
     slice_origin_timestamp_ = now;
-  client_->writeData(data.data(), data.length(), last_in_slice);
+  client_->writeData(data.data(), data.length(), last_in_slice,
+                     (now - TimeTicks::UnixEpoch()).InMillisecondsF());
 }
 
 void MediaRecorderHandler::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     const TimeTicks& timestamp) {
   for (const auto& recorder : video_recorders_)
     recorder->OnVideoFrameForTesting(frame, timestamp);
 }
 
 void MediaRecorderHandler::OnAudioBusForTesting(
     const media::AudioBus& audio_bus,
     const base::TimeTicks& timestamp) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content