Move ChunkDemuxer handling from WMPProxy to WMPI and remove ChunkDemuxerClient

webkit/media/webmediaplayer_impl.cc

 // Copyright (c) 2012 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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 #include "media/filters/audio_renderer_impl.h"
+#include "media/filters/chunk_demuxer.h"
 #include "media/filters/video_renderer_base.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVideoFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "v8/include/v8.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/media/filter_helpers.h"
@@ skipping 61 matching lines @@
 static WebKit::WebTimeRanges ConvertToWebTimeRanges(
     const media::Ranges<base::TimeDelta>& ranges) {
   WebKit::WebTimeRanges result(ranges.size());
   for (size_t i = 0; i < ranges.size(); i++) {
     result[i].start = ranges.start(i).InSecondsF();
     result[i].end = ranges.end(i).InSecondsF();
   }
   return result;
 }
 
+typedef base::Callback<void(const std::string&,
+                            const std::string&,

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

what's with these std::strings??

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

These are for the key_system and session_id. I'm not sure why they are always
empty strings for this code path. I'm just replicating the behavior that was in
WebMediaPlayerProxy::DemuxerNeedKey.

[Ami GONE FROM CHROMIUM, 2012/09/12 22:29:03]

Feel like adding a TODO to figure out whether these need to die or whether they
are placeholders for future functionality?  (in which case they should probably
die, too, unless that future is almost upon us...)

[acolwell GONE FROM CHROMIUM, 2012/09/13 00:16:23]

Done.

+                            scoped_array<uint8>,
+                            int)> OnNeedKeyCB;
+
+static void OnDemuxerNeedKeyTrampoline(
+    const scoped_refptr<base::MessageLoopProxy>& message_loop,
+    const OnNeedKeyCB& need_key_cb,
+    scoped_array<uint8> init_data,
+    int init_data_size) {
+  message_loop->PostTask(FROM_HERE, base::Bind(
+      need_key_cb, "", "", base::Passed(&init_data), init_data_size));
+}
+
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     media::FilterCollection* collection,
     WebKit::WebAudioSourceProvider* audio_source_provider,
     media::AudioRendererSink* audio_renderer_sink,
     media::MessageLoopFactory* message_loop_factory,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
@@ skipping 124 matching lines @@
   // Media streams pipelines can start immediately.
   if (BuildMediaStreamCollection(url, media_stream_client_,
                                  message_loop_factory_.get(),
                                  filter_collection_.get())) {
     supports_save_ = false;
     StartPipeline();
     return;
   }
 
   // Media source pipelines can start immediately.
-  if (BuildMediaSourceCollection(url, GetClient()->sourceURL(), proxy_,
-                                 message_loop_factory_.get(),
-                                 filter_collection_.get(),
-                                 &decryptor_)) {
+  if (!url.isEmpty() && url == GetClient()->sourceURL()) {
+    chunk_demuxer_ = new media::ChunkDemuxer(
+        BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
+        base::Bind(&OnDemuxerNeedKeyTrampoline,

[Ami GONE FROM CHROMIUM, 2012/09/12 18:45:34]

why not BIND_TO_RENDER_LOOP for this as well?

[acolwell GONE FROM CHROMIUM, 2012/09/12 22:03:53]

BindToLoop doesn't like the scoped_array<> in the callback signature.
BindToLoop's docs explicitly say it can't be used with arrays because it copies
its arguments.

[Ami GONE FROM CHROMIUM, 2012/09/12 22:29:03]

This isn't an array, it's a scoped_array.
I'm surprised that no amount of base::Passed()'ing made this work for you.

[acolwell GONE FROM CHROMIUM, 2012/09/13 00:16:23]

I was too. I'll left it as is for now and will change it if we figure out a way
to make it work with BindToLoop.

+                   main_loop_->message_loop_proxy(),
+                   base::Bind(&WebMediaPlayerImpl::OnNeedKey, AsWeakPtr())));
+
+    BuildMediaSourceCollection(chunk_demuxer_,
+                               message_loop_factory_.get(),
+                               filter_collection_.get(),
+                               &decryptor_);
     supports_save_ = false;
     StartPipeline();
     return;
   }
 
   // Otherwise it's a regular request which requires resolving the URL first.
   proxy_->set_data_source(
       new BufferedDataSource(main_loop_, frame_, media_log_,
                              base::Bind(&WebMediaPlayerImpl::NotifyDownloading,
                                         AsWeakPtr())));
@@ skipping 49 matching lines @@
   DCHECK_EQ(main_loop_, MessageLoop::current());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(float seconds) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   if (starting_ || seeking_) {
     pending_seek_ = true;
     pending_seek_seconds_ = seconds;
-    proxy_->DemuxerCancelPendingSeek();
+    if (chunk_demuxer_)
+      chunk_demuxer_->CancelPendingSeek();
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
 
   // Update our paused time.
   if (paused_)
     paused_time_ = seek_time;
 
   seeking_ = true;
 
-  proxy_->DemuxerStartWaitingForSeek();
+  if (chunk_demuxer_)
+    chunk_demuxer_->StartWaitingForSeek();
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
@@ skipping 273 matching lines @@
 WebKit::WebMediaPlayer::AddIdStatus WebMediaPlayerImpl::sourceAddId(
     const WebKit::WebString& id,
     const WebKit::WebString& type,
     const WebKit::WebVector<WebKit::WebString>& codecs) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   std::vector<std::string> new_codecs(codecs.size());
   for (size_t i = 0; i < codecs.size(); ++i)
     new_codecs[i] = codecs[i].utf8().data();
 
   return static_cast<WebKit::WebMediaPlayer::AddIdStatus>(
-      proxy_->DemuxerAddId(id.utf8().data(), type.utf8().data(),
-                           new_codecs));
+      chunk_demuxer_->AddId(id.utf8().data(), type.utf8().data(), new_codecs));
 }
 
 bool WebMediaPlayerImpl::sourceRemoveId(const WebKit::WebString& id) {
   DCHECK(!id.isEmpty());
-  proxy_->DemuxerRemoveId(id.utf8().data());
+  chunk_demuxer_->RemoveId(id.utf8().data());
   return true;
 }
 
 WebKit::WebTimeRanges WebMediaPlayerImpl::sourceBuffered(
     const WebKit::WebString& id) {
-  return ConvertToWebTimeRanges(proxy_->DemuxerBufferedRange(id.utf8().data()));
+  return ConvertToWebTimeRanges(
+      chunk_demuxer_->GetBufferedRanges(id.utf8().data()));
 }
 
 bool WebMediaPlayerImpl::sourceAppend(const WebKit::WebString& id,
                                       const unsigned char* data,
                                       unsigned length) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   float old_duration = duration();
-  if (!proxy_->DemuxerAppend(id.utf8().data(), data, length))
+  if (!chunk_demuxer_->AppendData(id.utf8().data(), data, length))
     return false;
 
   if (old_duration != duration())
     GetClient()->durationChanged();
 
   return true;
 }
 
 bool WebMediaPlayerImpl::sourceAbort(const WebKit::WebString& id) {
-  proxy_->DemuxerAbort(id.utf8().data());
+  chunk_demuxer_->Abort(id.utf8().data());
   return true;
 }
 
 void WebMediaPlayerImpl::sourceSetDuration(double new_duration) {
   if (static_cast<double>(duration()) == new_duration)
     return;
 
-  proxy_->DemuxerSetDuration(
+  chunk_demuxer_->SetDuration(
       base::TimeDelta::FromMicroseconds(
           new_duration * base::Time::kMicrosecondsPerSecond));
   GetClient()->durationChanged();
 }
 
 void WebMediaPlayerImpl::sourceEndOfStream(
     WebMediaPlayer::EndOfStreamStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   media::PipelineStatus pipeline_status = media::PIPELINE_OK;
 
   switch (status) {
     case WebMediaPlayer::EndOfStreamStatusNoError:
       break;
     case WebMediaPlayer::EndOfStreamStatusNetworkError:
       pipeline_status = media::PIPELINE_ERROR_NETWORK;
       break;
     case WebMediaPlayer::EndOfStreamStatusDecodeError:
       pipeline_status = media::PIPELINE_ERROR_DECODE;
       break;
     default:
       NOTIMPLEMENTED();
   }
 
   float old_duration = duration();
-  proxy_->DemuxerEndOfStream(pipeline_status);
+  chunk_demuxer_->EndOfStream(pipeline_status);
 
   if (old_duration != duration())
     GetClient()->durationChanged();
 }
 
 bool WebMediaPlayerImpl::sourceSetTimestampOffset(const WebKit::WebString& id,
                                                   double offset) {
   base::TimeDelta time_offset = base::TimeDelta::FromMicroseconds(
       offset * base::Time::kMicrosecondsPerSecond);
-  return proxy_->DemuxerSetTimestampOffset(id.utf8().data(), time_offset);
+  return chunk_demuxer_->SetTimestampOffset(id.utf8().data(), time_offset);
 }
 
 WebKit::WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::generateKeyRequest(const WebString& key_system,
                                        const unsigned char* init_data,
                                        unsigned init_data_length) {
   if (!IsSupportedKeySystem(key_system))
     return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   // We do not support run-time switching between key systems for now.
@@ skipping 166 matching lines @@
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
-
   GetClient()->sourceOpened();
 }
 
 void WebMediaPlayerImpl::OnKeyAdded(const std::string& key_system,
                                     const std::string& session_id) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->keyAdded(WebString::fromUTF8(key_system),
                         WebString::fromUTF8(session_id));
 }
@@ skipping 115 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 void WebMediaPlayerImpl::Destroy() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   // Tell the data source to abort any pending reads so that the pipeline is
   // not blocked when issuing stop commands to the other filters.
   if (proxy_) {
     proxy_->AbortDataSource();
-    proxy_->DemuxerShutdown();
+    if (chunk_demuxer_) {
+      chunk_demuxer_->Shutdown();
+      chunk_demuxer_ = NULL;
+    }
   }
 
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   base::WaitableEvent waiter(false, false);
   pipeline_->Stop(base::Bind(
       &base::WaitableEvent::Signal, base::Unretained(&waiter)));
   waiter.Wait();
 
   // Let V8 know we are not using extra resources anymore.
@@ skipping 22 matching lines @@
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media