Split WebMediaPlayerImpl::Proxy into its own class.

webkit/glue/webmediaplayer_impl.cc

 // Copyright (c) 2011 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/glue/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 13 matching lines @@
 #include "media/filters/null_audio_renderer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVideoFrame.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/glue/media/simple_data_source.h"
 #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;
 using WebKit::WebRect;
 using WebKit::WebSize;
 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.
 //
 // Vista has substantially lower performance than XP or Windows7.  If you speed
 // up a video too much, it can't keep up, and rendering stops updating except on
 // the time bar. For really high speeds, audio becomes a bottleneck and we just
 // use up the data we have, which may not achieve the speed requested, but will
 // not crash the tab.
 //
@@ skipping 22 matching lines @@
   }
 
   // Now we can safely cast to int64 microseconds.
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(integer));
 }
 
 }  // namespace
 
 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,
     media::MessageLoopFactory* message_loop_factory,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
     : network_state_(WebKit::WebMediaPlayer::Empty),
       ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_collection_(collection),
@@ skipping 22 matching lines @@
     NOTREACHED() << "Could not start PipelineThread";
     return false;
   }
 
   pipeline_ = new media::PipelineImpl(pipeline_message_loop);
 
   // Also we want to be notified of |main_loop_| destruction.
   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(
       SimpleDataSource::CreateFactory(MessageLoop::current(), frame,
                                       proxy_->GetBuildObserver()));
 
   // A sophisticated data source that does memory caching.
   scoped_ptr<media::DataSourceFactory> buffered_data_source_factory(
       BufferedDataSource::CreateFactory(MessageLoop::current(), frame,
                                         proxy_->GetBuildObserver()));
@@ skipping 72 matching lines @@
   // Get the preload value.
   setPreload(GetClient()->preload());
 
   // Initialize the pipeline.
   SetNetworkState(WebKit::WebMediaPlayer::Loading);
   SetReadyState(WebKit::WebMediaPlayer::HaveNothing);
   pipeline_->Start(
       filter_collection_.release(),
       url.spec(),
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineInitializationCallback));
-
+                  &WebMediaPlayerProxy::PipelineInitializationCallback));
   media_log_->Load(url.spec());
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
   DCHECK(MessageLoop::current() == main_loop_);
 }
 
 void WebMediaPlayerImpl::play() {
   DCHECK(MessageLoop::current() == main_loop_);
 
@@ skipping 46 matching lines @@
   }
 
   seeking_ = true;
 
   proxy_->DemuxerFlush();
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       NewCallback(proxy_.get(),
-                  &WebMediaPlayerImpl::Proxy::PipelineSeekCallback));
+                  &WebMediaPlayerProxy::PipelineSeekCallback));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): add method call when it has been implemented.
   return;
 }
 
 void WebMediaPlayerImpl::setRate(float rate) {
@@ skipping 499 matching lines @@
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue