Add --simple-data-source which uses simplified media resource loading.

Comes in really handy for demo purposes and for testing playback performance with buffering and range requests removed from the equation.

Review URL: http://codereview.chromium.org/109049

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15354 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 243 insertions, 9 deletions

diff --git a/chrome/renderer/media/simple_data_source.cc b/chrome/renderer/media/simple_data_source.cc
new file mode 100644
index 0000000..cb625e2
--- /dev/null
+++ b/chrome/renderer/media/simple_data_source.cc
@@ -0,0 +1,136 @@
+// Copyright (c) 2009 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 "base/process_util.h"
+#include "chrome/renderer/media/simple_data_source.h"
+#include "chrome/renderer/render_thread.h"
+#include "chrome/renderer/render_view.h"
+#include "chrome/renderer/webmediaplayer_delegate_impl.h"
+#include "media/base/filter_host.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request_status.h"
+#include "webkit/glue/webappcachecontext.h"
+
+SimpleDataSource::SimpleDataSource(int32 routing_id)
+    : routing_id_(routing_id),
+      render_loop_(RenderThread::current()->message_loop()),
+      size_(0),
+      position_(0) {
+}
+
+SimpleDataSource::~SimpleDataSource() {}
+
+void SimpleDataSource::Stop() {}
+
+bool SimpleDataSource::Initialize(const std::string& url) {
+  SetURL(url);
+
+  // Validate the URL.
+  GURL gurl(url);
+  if (!gurl.is_valid()) {
+    return false;
+  }
+
+  // Create our bridge and post a task to start loading the resource.
+  bridge_.reset(RenderThread::current()->resource_dispatcher()->CreateBridge(
+      "GET",
+      gurl,
+      gurl,
+      GURL::EmptyGURL(),  // TODO(scherkus): provide referer here.
+      "null",             // TODO(abarth): provide frame_origin
+      "null",             // TODO(abarth): provide main_frame_origin
+      "",
+      net::LOAD_BYPASS_CACHE,
+      base::GetCurrentProcId(),
+      ResourceType::MEDIA,
+      0,
+      // TODO(michaeln): delegate->mediaplayer->frame->
+      //                    app_cache_context()->context_id()
+      // For now don't service media resource requests from the appcache.
+      WebAppCacheContext::kNoAppCacheContextId,
+      routing_id_));
+  render_loop_->PostTask(FROM_HERE,
+                         NewRunnableMethod(this, &SimpleDataSource::StartTask));
+  return true;
+}
+
+const media::MediaFormat& SimpleDataSource::media_format() {
+  return media_format_;
+}
+
+size_t SimpleDataSource::Read(uint8* data, size_t size) {
+  size_t copied = std::min(size, static_cast<size_t>(size_ - position_));
+  memcpy(data, data_.c_str() + position_, copied);
+  position_ += copied;
+  return copied;
+}
+
+bool SimpleDataSource::GetPosition(int64* position_out) {
+  *position_out = position_;
+  return true;
+}
+
+bool SimpleDataSource::SetPosition(int64 position) {
+  if (position < 0 || position > size_)
+    return false;
+  position_ = position;
+  return true;
+}
+
+bool SimpleDataSource::GetSize(int64* size_out) {
+  *size_out = size_;
+  return true;
+}
+
+bool SimpleDataSource::IsSeekable() {
+  return true;
+}
+
+void SimpleDataSource::OnDownloadProgress(uint64 position, uint64 size) {}
+
+void SimpleDataSource::OnUploadProgress(uint64 position, uint64 size) {}
+
+void SimpleDataSource::OnReceivedRedirect(const GURL& new_url) {
+  SetURL(new_url.spec());
+}
+
+void SimpleDataSource::OnReceivedResponse(
+    const webkit_glue::ResourceLoaderBridge::ResponseInfo& info,
+    bool content_filtered) {
+  // This is a simple data source, so we assume 200 responses with the content
+  // length provided.
+  DCHECK(info.headers->response_code() == 200);
+  DCHECK(info.content_length != -1);
+  size_ = info.content_length;
+}
+
+void SimpleDataSource::OnReceivedData(const char* data, int len) {
+  data_.append(data, len);
+}
+
+void SimpleDataSource::OnCompletedRequest(const URLRequestStatus& status,
+                                          const std::string& security_info) {
+  DCHECK(size_ == data_.length());
+  position_ = 0;
+  bridge_.reset();
+  host_->InitializationComplete();
+}
+
+std::string SimpleDataSource::GetURLForDebugging() {
+  return url_;
+}
+
+void SimpleDataSource::SetURL(const std::string& url) {
+  url_ = url;
+  media_format_.Clear();
+  media_format_.SetAsString(media::MediaFormat::kMimeType,
+                            media::mime_type::kApplicationOctetStream);
+  media_format_.SetAsString(media::MediaFormat::kURL, url);
+}
+
+void SimpleDataSource::StartTask() {
+  DCHECK(MessageLoop::current() == render_loop_);
+  bridge_->Start(this);
+}
diff --git a/chrome/renderer/media/simple_data_source.h b/chrome/renderer/media/simple_data_source.h
new file mode 100644
index 0000000..049c24f
--- /dev/null
+++ b/chrome/renderer/media/simple_data_source.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2009 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.
+
+// An extremely simple implementation of DataSource that downloads the entire
+// media resource into memory before signaling that initialization has finished.
+// Primarily used to test <audio> and <video> with buffering/caching removed
+// from the equation.
+
+#ifndef CHROME_RENDERER_MEDIA_SIMPLE_DATA_SOURCE_H_
+#define CHROME_RENDERER_MEDIA_SIMPLE_DATA_SOURCE_H_
+
+#include "base/scoped_ptr.h"
+#include "media/base/factory.h"
+#include "media/base/filters.h"
+#include "webkit/glue/resource_loader_bridge.h"
+
+class MessageLoop;
+class WebMediaPlayerDelegateImpl;
+
+class SimpleDataSource :
+    public media::DataSource,
+    public webkit_glue::ResourceLoaderBridge::Peer {
+ public:
+  static media::FilterFactory* CreateFactory(int32 routing_id) {
+    return new media::FilterFactoryImpl1<SimpleDataSource, int32>(routing_id);
+  }
+
+  // MediaFilter implementation.
+  virtual void Stop();
+
+  // DataSource implementation.
+  virtual bool Initialize(const std::string& url);
+  virtual const media::MediaFormat& media_format();
+  virtual size_t Read(uint8* data, size_t size);
+  virtual bool GetPosition(int64* position_out);
+  virtual bool SetPosition(int64 position);
+  virtual bool GetSize(int64* size_out);
+  virtual bool IsSeekable();
+
+  // webkit_glue::ResourceLoaderBridge::Peer implementation.
+  virtual void OnDownloadProgress(uint64 position, uint64 size);
+  virtual void OnUploadProgress(uint64 position, uint64 size);
+  virtual void OnReceivedRedirect(const GURL& new_url);
+  virtual void OnReceivedResponse(
+      const webkit_glue::ResourceLoaderBridge::ResponseInfo& info,
+      bool content_filtered);
+  virtual void OnReceivedData(const char* data, int len);
+  virtual void OnCompletedRequest(const URLRequestStatus& status,
+                                  const std::string& security_info);
+  virtual std::string GetURLForDebugging();
+
+ private:
+  friend class media::FilterFactoryImpl1<SimpleDataSource, int32>;
+  SimpleDataSource(int32 routing_id);
+  virtual ~SimpleDataSource();
+
+  // Updates |url_| and |media_format_| with the given URL.
+  void SetURL(const std::string& url);
+
+  // Start the resource loading on the render thread.
+  void StartTask();
+
+  // Passed in during construction, used when creating the bridge.
+  int32 routing_id_;
+
+  // Primarily used for asserting the bridge is loading on the render thread.
+  MessageLoop* render_loop_;
+
+  // Bridge used to load the media resource.
+  scoped_ptr<webkit_glue::ResourceLoaderBridge> bridge_;
+
+  media::MediaFormat media_format_;
+  std::string url_;
+  std::string data_;
+  int64 size_;
+  int64 position_;
+
+  DISALLOW_COPY_AND_ASSIGN(SimpleDataSource);
+};
+
+#endif  // CHROME_RENDERER_MEDIA_SIMPLE_DATA_SOURCE_H_
diff --git a/chrome/renderer/renderer.vcproj b/chrome/renderer/renderer.vcproj
index 249f133..bd1f995 100644
--- a/chrome/renderer/renderer.vcproj
+++ b/chrome/renderer/renderer.vcproj
@@ -161,6 +161,14 @@
 				>
 			</File>
 			<File
+				RelativePath=".\media\simple_data_source.cc"
+				>
+			</File>
+			<File
+				RelativePath=".\media\simple_data_source.h"
+				>
+			</File>
+			<File
 				RelativePath=".\media\video_renderer_impl.cc"
 				>
 			</File>
diff --git a/chrome/renderer/webmediaplayer_delegate_impl.cc b/chrome/renderer/webmediaplayer_delegate_impl.cc
index bfece7c..00e65ab 100644
--- a/chrome/renderer/webmediaplayer_delegate_impl.cc
+++ b/chrome/renderer/webmediaplayer_delegate_impl.cc
@@ -9,6 +9,7 @@
 #include "chrome/renderer/media/audio_renderer_impl.h"
 #include "chrome/renderer/media/data_source_impl.h"
 #include "chrome/renderer/media/buffered_data_source.h"
+#include "chrome/renderer/media/simple_data_source.h"
 #include "chrome/renderer/media/video_renderer_impl.h"
 #include "chrome/renderer/render_view.h"
 #include "googleurl/src/gurl.h"
@@ -65,22 +66,29 @@ WebMediaPlayerDelegateImpl::WebMediaPlayerDelegateImpl(RenderView* view)
       web_media_player_(NULL),
       view_(view),
       tasks_(kLastTaskIndex) {
-  // TODO(hclam): Add filter factory for demuxer and decoders.
+  // Add in any custom filter factories first.
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableAudio)) {
+    filter_factory_->AddFactory(
+        media::NullAudioRenderer::CreateFilterFactory());
+  }
+  if (cmd_line->HasSwitch(switches::kSimpleDataSource)) {
+    filter_factory_->AddFactory(
+        SimpleDataSource::CreateFactory(view->routing_id()));
+  }
+
 #if defined(OS_WIN)
   // FFmpeg is not ready for Linux and Mac yet.
   filter_factory_->AddFactory(media::FFmpegDemuxer::CreateFilterFactory());
   filter_factory_->AddFactory(media::FFmpegAudioDecoder::CreateFactory());
   filter_factory_->AddFactory(media::FFmpegVideoDecoder::CreateFactory());
 #endif
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableAudio)) {
-    filter_factory_->AddFactory(
-        media::NullAudioRenderer::CreateFilterFactory());
-  } else {
-    filter_factory_->AddFactory(
-        AudioRendererImpl::CreateFactory(view_->audio_message_filter()));
-  }
-  filter_factory_->AddFactory(VideoRendererImpl::CreateFactory(this));
+
+  // Add in the default filter factories.
+  filter_factory_->AddFactory(
+      AudioRendererImpl::CreateFactory(view_->audio_message_filter()));
   filter_factory_->AddFactory(BufferedDataSource::CreateFactory(this));
+  filter_factory_->AddFactory(VideoRendererImpl::CreateFactory(this));
 }
 
 WebMediaPlayerDelegateImpl::~WebMediaPlayerDelegateImpl() {