MSE: Notify Blink SourceBuffer on init segment received

media/blink/websourcebuffer_impl.cc

 // Copyright 2013 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 "media/blink/websourcebuffer_impl.h"
 
 #include <limits>
 
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/callback_helpers.h"
 #include "base/float_util.h"
 #include "media/filters/chunk_demuxer.h"
+#include "third_party/WebKit/public/platform/WebSourceBufferClient.h"
 
 namespace media {
 
 static base::TimeDelta DoubleToTimeDelta(double time) {
   DCHECK(!base::IsNaN(time));
   DCHECK_NE(time, -std::numeric_limits<double>::infinity());
 
   if (time == std::numeric_limits<double>::infinity())
     return kInfiniteDuration();
 
   // Don't use base::TimeDelta::Max() here, as we want the largest finite time
   // delta.
   base::TimeDelta max_time = base::TimeDelta::FromInternalValue(kint64max - 1);
   double max_time_in_seconds = max_time.InSecondsF();
 
   if (time >= max_time_in_seconds)
     return max_time;
 
   return base::TimeDelta::FromMicroseconds(
       time * base::Time::kMicrosecondsPerSecond);
 }
 
 WebSourceBufferImpl::WebSourceBufferImpl(
     const std::string& id, ChunkDemuxer* demuxer)
     : id_(id),
       demuxer_(demuxer),
+      client_(NULL),
       append_window_end_(kInfiniteDuration()) {
   DCHECK(demuxer_);
 }
 
 WebSourceBufferImpl::~WebSourceBufferImpl() {
   DCHECK(!demuxer_) << "Object destroyed w/o removedFromMediaSource() call";
+  DCHECK(!client_);
+}
+
+void WebSourceBufferImpl::setClient(blink::WebSourceBufferClient* client) {
+  DCHECK(client);
+  DCHECK(!client_);
+  client_ = client;
 }
 
 bool WebSourceBufferImpl::setMode(WebSourceBuffer::AppendMode mode) {
   if (demuxer_->IsParsingMediaSegment(id_))
     return false;
 
   switch (mode) {
     case WebSourceBuffer::AppendModeSegments:
       demuxer_->SetSequenceMode(id_, false);
       return true;
@@ skipping 16 matching lines @@
   return result;
 }
 
 void WebSourceBufferImpl::append(
     const unsigned char* data,
     unsigned length,
     double* timestamp_offset) {
   base::TimeDelta old_offset = timestamp_offset_;
   demuxer_->AppendData(id_, data, length,
                        append_window_start_, append_window_end_,
-                       &timestamp_offset_);
+                       &timestamp_offset_,
+                       base::Bind(&WebSourceBufferImpl::InitSegmentReceived,
+                                  base::Unretained(this)));
 
   // Coded frame processing may update the timestamp offset. If the caller
   // provides a non-NULL |timestamp_offset| and frame processing changes the
   // timestamp offset, report the new offset to the caller. Do not update the
   // caller's offset otherwise, to preserve any pre-existing value that may have
   // more than microsecond precision.
   if (timestamp_offset && old_offset != timestamp_offset_)
     *timestamp_offset = timestamp_offset_.InSecondsF();
 }
 
@@ skipping 32 matching lines @@
 }
 
 void WebSourceBufferImpl::setAppendWindowEnd(double end) {
   DCHECK_GE(end, 0);
   append_window_end_ = DoubleToTimeDelta(end);
 }
 
 void WebSourceBufferImpl::removedFromMediaSource() {
   demuxer_->RemoveId(id_);
   demuxer_ = NULL;
+  client_ = NULL;
+}
+
+void WebSourceBufferImpl::InitSegmentReceived() {
+  DVLOG(1) << __FUNCTION__;
+  client_->initializationSegmentReceived();
 }
 
 }  // namespace media