Split WebMediaPlayerImpl::Proxy into its own class.

webkit/glue/webmediaplayer_impl.cc

Index: webkit/glue/webmediaplayer_impl.cc
diff --git a/webkit/glue/webmediaplayer_impl.cc b/webkit/glue/webmediaplayer_impl.cc
index 76a99093b2c8c518153216cc69a39ab826d2bde8..19a0c794c9fc7f5c5b6b5e505ee9ce352b31afc6 100644
--- a/webkit/glue/webmediaplayer_impl.cc
+++ b/webkit/glue/webmediaplayer_impl.cc
@@ -30,6 +30,7 @@
 #include "webkit/glue/media/media_stream_client.h"
 #include "webkit/glue/media/video_renderer_impl.h"
 #include "webkit/glue/media/web_video_renderer.h"
+#include "webkit/glue/webmediaplayer_proxy.h"
 #include "webkit/glue/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
@@ -39,11 +40,6 @@ using media::PipelineStatus;
 
 namespace {
 
-// Limits the maximum outstanding repaints posted on render thread.
-// This number of 50 is a guess, it does not take too much memory on the task
-// queue but gives up a pretty good latency on repaint.
-const int kMaxOutstandingRepaints = 50;
-
 // Limits the range of playback rate.
 //
 // TODO(kylep): Revisit these.
@@ -86,235 +82,6 @@ base::TimeDelta ConvertSecondsToTimestamp(float seconds) {
 
 namespace webkit_glue {
 
-/////////////////////////////////////////////////////////////////////////////
-// WebMediaPlayerImpl::Proxy implementation
-
-WebMediaPlayerImpl::Proxy::Proxy(MessageLoop* render_loop,
-                                 WebMediaPlayerImpl* webmediaplayer)
-    : render_loop_(render_loop),
-      webmediaplayer_(webmediaplayer),
-      outstanding_repaints_(0) {
-  DCHECK(render_loop_);
-  DCHECK(webmediaplayer_);
-}
-
-WebMediaPlayerImpl::Proxy::~Proxy() {
-  Detach();
-}
-
-void WebMediaPlayerImpl::Proxy::Repaint() {
-  base::AutoLock auto_lock(lock_);
-  if (outstanding_repaints_ < kMaxOutstandingRepaints) {
-    ++outstanding_repaints_;
-
-    render_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMediaPlayerImpl::Proxy::RepaintTask));
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::SetVideoRenderer(
-    scoped_refptr<WebVideoRenderer> video_renderer) {
-  video_renderer_ = video_renderer;
-}
-
-WebDataSourceBuildObserverHack* WebMediaPlayerImpl::Proxy::GetBuildObserver() {
-  if (!build_observer_.get())
-    build_observer_.reset(NewCallback(this, &Proxy::AddDataSource));
-  return build_observer_.get();
-}
-
-void WebMediaPlayerImpl::Proxy::Paint(SkCanvas* canvas,
-                                      const gfx::Rect& dest_rect) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (video_renderer_) {
-    video_renderer_->Paint(canvas, dest_rect);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::SetSize(const gfx::Rect& rect) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (video_renderer_) {
-    video_renderer_->SetRect(rect);
-  }
-}
-
-bool WebMediaPlayerImpl::Proxy::HasSingleOrigin() {
-  DCHECK(MessageLoop::current() == render_loop_);
-
-  base::AutoLock auto_lock(data_sources_lock_);
-
-  for (DataSourceList::iterator itr = data_sources_.begin();
-       itr != data_sources_.end();
-       itr++) {
-    if (!(*itr)->HasSingleOrigin())
-      return false;
-  }
-  return true;
-}
-
-void WebMediaPlayerImpl::Proxy::AbortDataSources() {
-  DCHECK(MessageLoop::current() == render_loop_);
-  base::AutoLock auto_lock(data_sources_lock_);
-
-  for (DataSourceList::iterator itr = data_sources_.begin();
-       itr != data_sources_.end();
-       itr++) {
-    (*itr)->Abort();
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::Detach() {
-  DCHECK(MessageLoop::current() == render_loop_);
-  webmediaplayer_ = NULL;
-  video_renderer_ = NULL;
-
-  {
-    base::AutoLock auto_lock(data_sources_lock_);
-    data_sources_.clear();
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineInitializationCallback(
-    PipelineStatus status) {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::PipelineInitializationTask, status));
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineSeekCallback(PipelineStatus status) {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::PipelineSeekTask, status));
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineEndedCallback(PipelineStatus status) {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::PipelineEndedTask, status));
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineErrorCallback(PipelineStatus error) {
-  DCHECK_NE(error, media::PIPELINE_OK);
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::PipelineErrorTask, error));
-}
-
-void WebMediaPlayerImpl::Proxy::NetworkEventCallback(PipelineStatus status) {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::NetworkEventTask, status));
-}
-
-void WebMediaPlayerImpl::Proxy::AddDataSource(WebDataSource* data_source) {
-  base::AutoLock auto_lock(data_sources_lock_);
-  data_sources_.push_back(make_scoped_refptr(data_source));
-}
-
-void WebMediaPlayerImpl::Proxy::RepaintTask() {
-  DCHECK(MessageLoop::current() == render_loop_);
-  {
-    base::AutoLock auto_lock(lock_);
-    --outstanding_repaints_;
-    DCHECK_GE(outstanding_repaints_, 0);
-  }
-  if (webmediaplayer_) {
-    webmediaplayer_->Repaint();
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineInitializationTask(
-    PipelineStatus status) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineInitialize(status);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineSeekTask(PipelineStatus status) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineSeek(status);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineEndedTask(PipelineStatus status) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineEnded(status);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::PipelineErrorTask(PipelineStatus error) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (webmediaplayer_) {
-    webmediaplayer_->OnPipelineError(error);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::NetworkEventTask(PipelineStatus status) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  if (webmediaplayer_) {
-    webmediaplayer_->OnNetworkEvent(status);
-  }
-}
-
-void WebMediaPlayerImpl::Proxy::GetCurrentFrame(
-    scoped_refptr<media::VideoFrame>* frame_out) {
-  if (video_renderer_)
-    video_renderer_->GetCurrentFrame(frame_out);
-}
-
-void WebMediaPlayerImpl::Proxy::PutCurrentFrame(
-    scoped_refptr<media::VideoFrame> frame) {
-  if (video_renderer_)
-    video_renderer_->PutCurrentFrame(frame);
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerOpened(media::ChunkDemuxer* demuxer) {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::DemuxerOpenedTask,
-      scoped_refptr<media::ChunkDemuxer>(demuxer)));
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerClosed() {
-  render_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &WebMediaPlayerImpl::Proxy::DemuxerClosedTask));
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerFlush() {
-  if (chunk_demuxer_.get())
-    chunk_demuxer_->FlushData();
-}
-
-bool WebMediaPlayerImpl::Proxy::DemuxerAppend(const uint8* data,
-                                              size_t length) {
-  if (chunk_demuxer_.get())
-    return chunk_demuxer_->AppendData(data, length);
-  return false;
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerEndOfStream(
-    media::PipelineStatus status) {
-  if (chunk_demuxer_.get())
-    chunk_demuxer_->EndOfStream(status);
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerShutdown() {
-  if (chunk_demuxer_.get())
-    chunk_demuxer_->Shutdown();
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerOpenedTask(
-    const scoped_refptr<media::ChunkDemuxer>& demuxer) {
-  DCHECK(MessageLoop::current() == render_loop_);
-  chunk_demuxer_ = demuxer;
-  if (webmediaplayer_)
-    webmediaplayer_->OnDemuxerOpened();
-}
-
-void WebMediaPlayerImpl::Proxy::DemuxerClosedTask() {
-  chunk_demuxer_ = NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// WebMediaPlayerImpl implementation
-
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebMediaPlayerClient* client,
     media::FilterCollection* collection,
@@ -354,18 +121,18 @@ bool WebMediaPlayerImpl::Initialize(
   main_loop_->AddDestructionObserver(this);
 
   // Creates the proxy.
-  proxy_ = new Proxy(main_loop_, this);
-  web_video_renderer->SetWebMediaPlayerImplProxy(proxy_);
+  proxy_ = new WebMediaPlayerProxy(main_loop_, this);
+  web_video_renderer->SetWebMediaPlayerProxy(proxy_);
   proxy_->SetVideoRenderer(web_video_renderer);
 
   // Set our pipeline callbacks.
   pipeline_->Init(
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineEndedCallback),
+                  &WebMediaPlayerProxy::PipelineEndedCallback),
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineErrorCallback),
+                  &WebMediaPlayerProxy::PipelineErrorCallback),
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::NetworkEventCallback));
+                  &WebMediaPlayerProxy::NetworkEventCallback));
 
   // A simple data source that keeps all data in memory.
   scoped_ptr<media::DataSourceFactory> simple_data_source_factory(
@@ -457,7 +224,7 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
       filter_collection_.release(),
       url.spec(),
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineInitializationCallback));
+                  &WebMediaPlayerProxy::PipelineInitializationCallback));
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
@@ -519,7 +286,7 @@ void WebMediaPlayerImpl::seek(float seconds) {
   pipeline_->Seek(
       seek_time,
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineSeekCallback));
+                  &WebMediaPlayerProxy::PipelineSeekCallback));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {