Refactor media player to move away from webkit_glue

Highlights:
1. WebCore::MediaPlayerPrivate now only has one static method that constructs WebMediaPlayerClient
2. Implementation of WebCore::MediaPlayerPrivateInterface now is WebMediaPlayerClient
3. WebMediaPlayerClient does the delgation to WebMediaPlayer
4. Implemtnation of real media player will go into chrome/renderer and implements WebMediaPlayer

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

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

10 files changed, 177 insertions, 219 deletions

diff --git a/chrome/renderer/media/buffered_data_source.cc b/chrome/renderer/media/buffered_data_source.cc
index f6daf58..67d3b9d 100644
--- a/chrome/renderer/media/buffered_data_source.cc
+++ b/chrome/renderer/media/buffered_data_source.cc
@@ -9,7 +9,6 @@
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/renderer/media/buffered_data_source.h"
 #include "chrome/renderer/render_view.h"
-#include "chrome/renderer/webmediaplayer_delegate_impl.h"
 #include "chrome/renderer/render_thread.h"
 #include "media/base/filter_host.h"
 #include "net/base/load_flags.h"
@@ -36,7 +35,7 @@ bool IsSchemeSupported(const GURL& url) {
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader
-BufferedResourceLoader::BufferedResourceLoader(int route_id,
+BufferedResourceLoader::BufferedResourceLoader(int32 routing_id,
                                                const GURL& url,
                                                int64 first_byte_position,
                                                int64 last_byte_position)
@@ -52,7 +51,7 @@ BufferedResourceLoader::BufferedResourceLoader(int route_id,
       completed_(false),
       range_requested_(false),
       async_start_(false),
-      route_id_(route_id),
+      routing_id_(routing_id),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
@@ -109,7 +108,7 @@ int BufferedResourceLoader::Start(net::CompletionCallback* start_callback) {
       //                    app_cache_context()->context_id()
       // For now don't service media resource requests from the appcache.
       WebAppCacheContext::kNoAppCacheContextId,
-      route_id_));
+      routing_id_));
 
   // We may receive stop signal while we are inside this method, it's because
   // Start() may get called on demuxer thread while Stop() is called on
@@ -458,8 +457,8 @@ void BufferedResourceLoader::InvokeAndResetStartCallback(int error) {
 
 //////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource
-BufferedDataSource::BufferedDataSource(WebMediaPlayerDelegateImpl* delegate)
-    : delegate_(delegate),
+BufferedDataSource::BufferedDataSource(int routing_id)
+    : routing_id_(routing_id),
       stopped_(false),
       position_(0),
       total_bytes_(kPositionNotSpecified),
@@ -505,8 +504,7 @@ bool BufferedDataSource::Initialize(const std::string& url) {
     AutoLock auto_lock(lock_);
     if (!stopped_) {
       buffered_resource_loader_ = new BufferedResourceLoader(
-          delegate_->view()->routing_id(),
-          url_, kPositionNotSpecified, kPositionNotSpecified);
+          routing_id_, url_, kPositionNotSpecified, kPositionNotSpecified);
       resource_loader = buffered_resource_loader_;
     }
   }
@@ -564,8 +562,7 @@ size_t BufferedDataSource::Read(uint8* data, size_t size) {
 
         // Create a new resource loader.
         resource_loader =
-            new BufferedResourceLoader(delegate_->view()->routing_id(),
-                                       url_, position_,
+            new BufferedResourceLoader(routing_id_, url_, position_,
                                        kPositionNotSpecified);
         buffered_resource_loader_ = resource_loader;
       }
diff --git a/chrome/renderer/media/buffered_data_source.h b/chrome/renderer/media/buffered_data_source.h
index bd80402..cc1a0bb 100644
--- a/chrome/renderer/media/buffered_data_source.h
+++ b/chrome/renderer/media/buffered_data_source.h
@@ -20,8 +20,6 @@
 #include "webkit/glue/resource_loader_bridge.h"
 #include "googleurl/src/gurl.h"
 
-class WebMediaPlayerDelegateImpl;
-
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader
 // This class works inside demuxer thread and render thread. It contains a
@@ -32,7 +30,7 @@ class BufferedResourceLoader :
     public base::RefCountedThreadSafe<BufferedResourceLoader>,
     public webkit_glue::ResourceLoaderBridge::Peer {
  public:
-  BufferedResourceLoader(int route_id,
+  BufferedResourceLoader(int32 routing_id,
                          const GURL& url,
                          int64 first_byte_position,
                          int64 last_byte_position);
@@ -139,7 +137,7 @@ class BufferedResourceLoader :
   bool range_requested_;
   bool async_start_;
 
-  int route_id_;
+  int32 routing_id_;
   GURL url_;
   int64 first_byte_position_;
   int64 last_byte_position_;
@@ -161,10 +159,8 @@ class BufferedDataSource : public media::DataSource {
  public:
   // Methods called from pipeline thread
   // Static methods for creating this class.
-  static media::FilterFactory* CreateFactory(
-      WebMediaPlayerDelegateImpl* delegate) {
-    return new media::FilterFactoryImpl1<BufferedDataSource,
-        WebMediaPlayerDelegateImpl*>(delegate);
+  static media::FilterFactory* CreateFactory(int32 routing_id) {
+    return new media::FilterFactoryImpl1<BufferedDataSource, int32>(routing_id);
   }
   virtual bool Initialize(const std::string& url);
 
@@ -182,8 +178,7 @@ class BufferedDataSource : public media::DataSource {
   const media::MediaFormat& media_format();
 
  private:
-  friend class media::FilterFactoryImpl1<BufferedDataSource,
-                                         WebMediaPlayerDelegateImpl*>;
+  friend class media::FilterFactoryImpl1<BufferedDataSource, int32>;
   // Call to filter host to trigger an error, be sure not to call this method
   // while the lock is acquired.
   void HandleError(media::PipelineError error);
@@ -194,17 +189,13 @@ class BufferedDataSource : public media::DataSource {
   void InitialRequestStarted(int error);
   void OnInitialRequestStarted(int error);
 
-  explicit BufferedDataSource(WebMediaPlayerDelegateImpl* delegate);
+  explicit BufferedDataSource(int32 routing_id);
   virtual ~BufferedDataSource();
 
   media::MediaFormat media_format_;
   GURL url_;
 
-  // Pointer to the delegate which provides access to RenderView, this is set
-  // in construction and can be accessed in all threads safely.
-  // TODO(hclam): get rid of this and save the routing id and pointer to
-  // ResourceDispatcher.
-  WebMediaPlayerDelegateImpl* delegate_;
+  int32 routing_id_;
 
   // A common lock for protecting members accessed by multiple threads.
   Lock lock_;
diff --git a/chrome/renderer/media/simple_data_source.cc b/chrome/renderer/media/simple_data_source.cc
index cb625e2..b1644b7 100644
--- a/chrome/renderer/media/simple_data_source.cc
+++ b/chrome/renderer/media/simple_data_source.cc
@@ -6,7 +6,6 @@
 #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"
diff --git a/chrome/renderer/media/video_renderer_impl.cc b/chrome/renderer/media/video_renderer_impl.cc
index ed1704f..be3466c 100644
--- a/chrome/renderer/media/video_renderer_impl.cc
+++ b/chrome/renderer/media/video_renderer_impl.cc
@@ -5,7 +5,7 @@
 #include "chrome/renderer/media/video_renderer_impl.h"
 #include "media/base/yuv_convert.h"
 
-VideoRendererImpl::VideoRendererImpl(WebMediaPlayerDelegateImpl* delegate)
+VideoRendererImpl::VideoRendererImpl(WebMediaPlayerImpl* delegate)
     : delegate_(delegate),
       last_converted_frame_(NULL) {
   // TODO(hclam): decide whether to do the following line in this thread or
diff --git a/chrome/renderer/media/video_renderer_impl.h b/chrome/renderer/media/video_renderer_impl.h
index 01ded10..9a39933 100644
--- a/chrome/renderer/media/video_renderer_impl.h
+++ b/chrome/renderer/media/video_renderer_impl.h
@@ -17,12 +17,12 @@
 #include "base/gfx/platform_canvas.h"
 #include "base/gfx/rect.h"
 #include "base/gfx/size.h"
-#include "chrome/renderer/webmediaplayer_delegate_impl.h"
+#include "chrome/renderer/webmediaplayer_impl.h"
 #include "media/base/buffers.h"
 #include "media/base/factory.h"
 #include "media/base/filters.h"
 #include "media/filters/video_renderer_base.h"
-#include "webkit/glue/webmediaplayer_delegate.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebMediaPlayer.h"
 
 class VideoRendererImpl : public media::VideoRendererBase {
  public:
@@ -39,10 +39,9 @@ class VideoRendererImpl : public media::VideoRendererBase {
   virtual void Paint(skia::PlatformCanvas* canvas, const gfx::Rect& dest_rect);
 
   // Static method for creating factory for this object.
-  static media::FilterFactory* CreateFactory(
-      WebMediaPlayerDelegateImpl* delegate) {
-    return new media::FilterFactoryImpl1<
-        VideoRendererImpl, WebMediaPlayerDelegateImpl*>(delegate);
+  static media::FilterFactory* CreateFactory(WebMediaPlayerImpl* delegate) {
+    return new media::FilterFactoryImpl1<VideoRendererImpl,
+                                         WebMediaPlayerImpl*>(delegate);
   }
 
  private:
@@ -56,11 +55,11 @@ class VideoRendererImpl : public media::VideoRendererBase {
   virtual void OnPaintNeeded();
 
   friend class media::FilterFactoryImpl1<VideoRendererImpl,
-                                         WebMediaPlayerDelegateImpl*>;
+                                         WebMediaPlayerImpl*>;
 
   // Constructor and destructor are private.  Only the filter factory is
   // allowed to create instances.
-  explicit VideoRendererImpl(WebMediaPlayerDelegateImpl* delegate);
+  explicit VideoRendererImpl(WebMediaPlayerImpl* delegate);
   virtual ~VideoRendererImpl() {}
 
   // Internal method used by the Paint method to convert the specified video
@@ -68,7 +67,7 @@ class VideoRendererImpl : public media::VideoRendererBase {
   void CopyToCurrentFrame(media::VideoFrame* video_frame);
 
   // Pointer to our parent object that is called to request repaints.
-  WebMediaPlayerDelegateImpl* delegate_;
+  WebMediaPlayerImpl* delegate_;
 
   // An RGB bitmap used to convert the video frames.
   SkBitmap bitmap_;
diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc
index 03df749..4db143d 100644
--- a/chrome/renderer/render_view.cc
+++ b/chrome/renderer/render_view.cc
@@ -39,7 +39,7 @@
 #include "chrome/renderer/renderer_logging.h"
 #include "chrome/renderer/user_script_slave.h"
 #include "chrome/renderer/visitedlink_slave.h"
-#include "chrome/renderer/webmediaplayer_delegate_impl.h"
+#include "chrome/renderer/webmediaplayer_impl.h"
 #include "chrome/renderer/webplugin_delegate_proxy.h"
 #include "chrome/renderer/webworker_proxy.h"
 #include "grit/generated_resources.h"
@@ -1872,11 +1872,12 @@ WebPluginDelegate* RenderView::CreatePluginDelegate(
 #endif
 }
 
-webkit_glue::WebMediaPlayerDelegate* RenderView::CreateMediaPlayerDelegate() {
+WebKit::WebMediaPlayer* RenderView::CreateWebMediaPlayer(
+    WebKit::WebMediaPlayerClient* client) {
 #if defined(OS_WIN)
-  return new WebMediaPlayerDelegateImpl(this);
+  return new WebMediaPlayerImpl(this, client);
 #else
-  // TODO(port)
+  // TODO(port): media player is not functional other than on Windows.
   NOTIMPLEMENTED();
   return NULL;
 #endif
diff --git a/chrome/renderer/render_view.h b/chrome/renderer/render_view.h
index bdd415c..17abcc2 100644
--- a/chrome/renderer/render_view.h
+++ b/chrome/renderer/render_view.h
@@ -74,6 +74,8 @@ struct FileUploadData;
 namespace WebKit {
 class WebDragData;
 struct WebFindOptions;
+class WebMediaPlayer;
+class WebMediaPlayerClient;
 }
 
 // We need to prevent a page from trying to create infinite popups. It is not
@@ -244,7 +246,8 @@ class RenderView : public RenderWidget,
       const std::string& clsid,
       std::string* actual_mime_type);
   virtual WebKit::WebWorker* CreateWebWorker(WebKit::WebWorkerClient* client);
-  virtual webkit_glue::WebMediaPlayerDelegate* CreateMediaPlayerDelegate();
+  virtual WebKit::WebMediaPlayer* CreateWebMediaPlayer(
+      WebKit::WebMediaPlayerClient* client);
   virtual void OnMissingPluginStatus(WebPluginDelegate* delegate, int status);
   virtual void OpenURL(WebView* webview, const GURL& url,
                        const GURL& referrer,
diff --git a/chrome/renderer/renderer.vcproj b/chrome/renderer/renderer.vcproj
index bd1f995..b86fae6 100644
--- a/chrome/renderer/renderer.vcproj
+++ b/chrome/renderer/renderer.vcproj
@@ -153,14 +153,6 @@
 				>
 			</File>
 			<File
-				RelativePath=".\media\data_source_impl.cc"
-				>
-			</File>
-			<File
-				RelativePath=".\media\data_source_impl.h"
-				>
-			</File>
-			<File
 				RelativePath=".\media\simple_data_source.cc"
 				>
 			</File>
@@ -438,11 +430,11 @@
 			>
 		</File>
 		<File
-			RelativePath=".\webmediaplayer_delegate_impl.cc"
+			RelativePath=".\webmediaplayer_impl.cc"
 			>
 		</File>
 		<File
-			RelativePath=".\webmediaplayer_delegate_impl.h"
+			RelativePath=".\webmediaplayer_impl.h"
 			>
 		</File>
 		<File
diff --git a/chrome/renderer/webmediaplayer_delegate_impl.cc b/chrome/renderer/webmediaplayer_impl.cc
index 00e65ab..6966479 100644
--- a/chrome/renderer/webmediaplayer_delegate_impl.cc
+++ b/chrome/renderer/webmediaplayer_impl.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/renderer/webmediaplayer_delegate_impl.h"
+#include "chrome/renderer/webmediaplayer_impl.h"
 
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
@@ -22,6 +22,7 @@
 #include "media/filters/null_audio_renderer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSize.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebURL.h"
 
 using WebKit::WebRect;
 using WebKit::WebSize;
@@ -31,39 +32,40 @@ using WebKit::WebSize;
 
 class NotifyWebMediaPlayerTask : public CancelableTask {
  public:
-  NotifyWebMediaPlayerTask(WebMediaPlayerDelegateImpl* delegate,
-                           WebMediaPlayerMethod method)
-      : delegate_(delegate),
+  NotifyWebMediaPlayerTask(WebMediaPlayerImpl* media_player,
+                           WebMediaPlayerClientMethod method)
+      : media_player_(media_player),
         method_(method) {}
 
   virtual void Run() {
-    if (delegate_) {
-      (delegate_->web_media_player()->*(method_))();
-      delegate_->DidTask(this);
+    if (media_player_) {
+      (media_player_->client()->*(method_))();
+      media_player_->DidTask(this);
     }
   }
 
   virtual void Cancel() {
-    delegate_ = NULL;
+    media_player_ = NULL;
   }
 
  private:
-  WebMediaPlayerDelegateImpl* delegate_;
-  WebMediaPlayerMethod method_;
+  WebMediaPlayerImpl* media_player_;
+  WebMediaPlayerClientMethod method_;
 
   DISALLOW_COPY_AND_ASSIGN(NotifyWebMediaPlayerTask);
 };
 
 /////////////////////////////////////////////////////////////////////////////
-// WebMediaPlayerDelegateImpl implementation
+// WebMediaPlayerImpl implementation
 
-WebMediaPlayerDelegateImpl::WebMediaPlayerDelegateImpl(RenderView* view)
-    : network_state_(webkit_glue::WebMediaPlayer::EMPTY),
-      ready_state_(webkit_glue::WebMediaPlayer::HAVE_NOTHING),
+WebMediaPlayerImpl::WebMediaPlayerImpl(RenderView* view,
+                                       WebKit::WebMediaPlayerClient* client)
+    : network_state_(WebKit::WebMediaPlayer::Empty),
+      ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_factory_(new media::FilterFactoryCollection()),
       video_renderer_(NULL),
-      web_media_player_(NULL),
+      client_(client),
       view_(view),
       tasks_(kLastTaskIndex) {
   // Add in any custom filter factories first.
@@ -87,57 +89,48 @@ WebMediaPlayerDelegateImpl::WebMediaPlayerDelegateImpl(RenderView* view)
   // Add in the default filter factories.
   filter_factory_->AddFactory(
       AudioRendererImpl::CreateFactory(view_->audio_message_filter()));
-  filter_factory_->AddFactory(BufferedDataSource::CreateFactory(this));
+  filter_factory_->AddFactory(
+      BufferedDataSource::CreateFactory(view->routing_id()));
   filter_factory_->AddFactory(VideoRendererImpl::CreateFactory(this));
+
+  DCHECK(client_);
+
+  // Saves the current message loop.
+  DCHECK(!main_loop_);
+  main_loop_ = MessageLoop::current();
+
+  // Also we want to be notified of |main_loop_| destruction.
+  main_loop_->AddDestructionObserver(this);
 }
 
-WebMediaPlayerDelegateImpl::~WebMediaPlayerDelegateImpl() {
+WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   pipeline_.Stop();
 
-  // Cancel all tasks posted on the main_loop_.
+  // Cancel all tasks posted on the |main_loop_|.
   CancelAllTasks();
 
-  // After cancelling all tasks, we are sure there will be no calls to
-  // web_media_player_, so we are safe to delete it.
-  if (web_media_player_) {
-    delete web_media_player_;
-  }
-
-  // Finally tell the main_loop_ we don't want to be notified of destruction
+  // Finally tell the |main_loop_| we don't want to be notified of destruction
   // event.
   if (main_loop_) {
     main_loop_->RemoveDestructionObserver(this);
   }
 }
 
-void WebMediaPlayerDelegateImpl::Initialize(
-    webkit_glue::WebMediaPlayer* media_player) {
-  DCHECK(!web_media_player_);
-  web_media_player_ = media_player;
-
-  // Saves the current message loop.
-  DCHECK(!main_loop_);
-  main_loop_ = MessageLoop::current();
-
-  // Also we want to be notified of main_loop_ destruction.
-  main_loop_->AddDestructionObserver(this);
-}
-
-void WebMediaPlayerDelegateImpl::Load(const GURL& url) {
+void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // Initialize the pipeline
   pipeline_.Start(filter_factory_.get(), url.spec(),
-      NewCallback(this, &WebMediaPlayerDelegateImpl::DidInitializePipeline));
+      NewCallback(this, &WebMediaPlayerImpl::DidInitializePipeline));
 }
 
-void WebMediaPlayerDelegateImpl::CancelLoad() {
+void WebMediaPlayerImpl::cancelLoad() {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(hclam): Calls to render_view_ to stop resource load
 }
 
-void WebMediaPlayerDelegateImpl::Play() {
+void WebMediaPlayerImpl::play() {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(hclam): We should restore the previous playback rate rather than
@@ -145,20 +138,20 @@ void WebMediaPlayerDelegateImpl::Play() {
   pipeline_.SetPlaybackRate(1.0f);
 }
 
-void WebMediaPlayerDelegateImpl::Pause() {
+void WebMediaPlayerImpl::pause() {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   pipeline_.SetPlaybackRate(0.0f);
 }
 
-void WebMediaPlayerDelegateImpl::Stop() {
+void WebMediaPlayerImpl::stop() {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // We can fire Stop() multiple times.
   pipeline_.Stop();
 }
 
-void WebMediaPlayerDelegateImpl::Seek(float seconds) {
+void WebMediaPlayerImpl::seek(float seconds) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   pipeline_.Seek(base::TimeDelta::FromSeconds(static_cast<int64>(seconds)));
@@ -168,116 +161,101 @@ void WebMediaPlayerDelegateImpl::Seek(float seconds) {
   //
   // TODO(scherkus): add a seek completion callback to the pipeline.
   PostTask(kTimeChangedTaskIndex,
-           &webkit_glue::WebMediaPlayer::NotifyTimeChange);
+           &WebKit::WebMediaPlayerClient::timeChanged);
 }
 
-void WebMediaPlayerDelegateImpl::SetEndTime(float seconds) {
+void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(hclam): add method call when it has been implemented.
   return;
 }
 
-void WebMediaPlayerDelegateImpl::SetPlaybackRate(float rate) {
+void WebMediaPlayerImpl::setRate(float rate) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   pipeline_.SetPlaybackRate(rate);
 }
 
-void WebMediaPlayerDelegateImpl::SetVolume(float volume) {
+void WebMediaPlayerImpl::setVolume(float volume) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   pipeline_.SetVolume(volume);
 }
 
-void WebMediaPlayerDelegateImpl::SetVisible(bool visible) {
+void WebMediaPlayerImpl::setVisible(bool visible) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(hclam): add appropriate method call when pipeline has it implemented.
   return;
 }
 
-bool WebMediaPlayerDelegateImpl::IsTotalBytesKnown() {
+bool WebMediaPlayerImpl::setAutoBuffer(bool autoBuffer) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
-  return pipeline_.GetTotalBytes() != 0;
+  return false;
 }
 
-bool WebMediaPlayerDelegateImpl::IsVideo() const {
+bool WebMediaPlayerImpl::totalBytesKnown() {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
-  size_t width, height;
-  pipeline_.GetVideoSize(&width, &height);
-  return width != 0 && height != 0;
+  return pipeline_.GetTotalBytes() != 0;
 }
 
-size_t WebMediaPlayerDelegateImpl::GetWidth() const {
+bool WebMediaPlayerImpl::hasVideo() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   size_t width, height;
   pipeline_.GetVideoSize(&width, &height);
-  return width;
+  return width != 0 && height != 0;
 }
 
-size_t WebMediaPlayerDelegateImpl::GetHeight() const {
+WebKit::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   size_t width, height;
   pipeline_.GetVideoSize(&width, &height);
-  return height;
+  return WebKit::WebSize(width, height);
 }
 
-bool WebMediaPlayerDelegateImpl::IsPaused() const {
+bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return pipeline_.GetPlaybackRate() == 0.0f;
 }
 
-bool WebMediaPlayerDelegateImpl::IsSeeking() const {
+bool WebMediaPlayerImpl::seeking() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return tasks_[kTimeChangedTaskIndex] != NULL;
 }
 
-float WebMediaPlayerDelegateImpl::GetDuration() const {
+float WebMediaPlayerImpl::duration() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return static_cast<float>(pipeline_.GetDuration().InSecondsF());
 }
 
-float WebMediaPlayerDelegateImpl::GetCurrentTime() const {
+float WebMediaPlayerImpl::currentTime() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return static_cast<float>(pipeline_.GetTime().InSecondsF());
 }
 
-
-float WebMediaPlayerDelegateImpl::GetPlayBackRate() const {
-  DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
-
-  return pipeline_.GetPlaybackRate();
-}
-
-float WebMediaPlayerDelegateImpl::GetVolume() const {
-  DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
-
-  return pipeline_.GetVolume();
-}
-
-int WebMediaPlayerDelegateImpl::GetDataRate() const {
+int WebMediaPlayerImpl::dataRate() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(hclam): Add this method call if pipeline has it in the interface.
   return 0;
 }
 
-float WebMediaPlayerDelegateImpl::GetMaxTimeBuffered() const {
+float WebMediaPlayerImpl::maxTimeBuffered() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return static_cast<float>(pipeline_.GetBufferedTime().InSecondsF());
 }
 
-float WebMediaPlayerDelegateImpl::GetMaxTimeSeekable() const {
+float WebMediaPlayerImpl::maxTimeSeekable() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   // TODO(scherkus): move this logic down into the pipeline.
@@ -290,19 +268,19 @@ float WebMediaPlayerDelegateImpl::GetMaxTimeSeekable() const {
   return static_cast<float>(duration * (buffered_bytes / total_bytes));
 }
 
-int64 WebMediaPlayerDelegateImpl::GetBytesLoaded() const {
+unsigned long long WebMediaPlayerImpl::bytesLoaded() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return pipeline_.GetBufferedBytes();
 }
 
-int64 WebMediaPlayerDelegateImpl::GetTotalBytes() const {
+unsigned long long WebMediaPlayerImpl::totalBytes() const {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   return pipeline_.GetTotalBytes();
 }
 
-void WebMediaPlayerDelegateImpl::SetSize(const WebSize& size) {
+void WebMediaPlayerImpl::setSize(const WebSize& size) {
   DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
 
   if (video_renderer_) {
@@ -311,42 +289,43 @@ void WebMediaPlayerDelegateImpl::SetSize(const WebSize& size) {
   }
 }
 
-void WebMediaPlayerDelegateImpl::Paint(skia::PlatformCanvas *canvas,
-                                       const WebRect& rect) {
+void WebMediaPlayerImpl::paint(skia::PlatformCanvas* canvas,
+                               const WebRect& rect) {
+  DCHECK(main_loop_ && MessageLoop::current() == main_loop_);
+
   if (video_renderer_) {
     video_renderer_->Paint(canvas, rect);
   }
 }
 
-void WebMediaPlayerDelegateImpl::WillDestroyCurrentMessageLoop() {
+void WebMediaPlayerImpl::WillDestroyCurrentMessageLoop() {
   pipeline_.Stop();
 }
 
-void WebMediaPlayerDelegateImpl::DidInitializePipeline(bool successful) {
+void WebMediaPlayerImpl::DidInitializePipeline(bool successful) {
   if (successful) {
-    // Since we have initialized the pipeline, we should be able to play it.
-    // And we skip LOADED_METADATA state and starting with LOADED_FIRST_FRAME.
-    ready_state_ = webkit_glue::WebMediaPlayer::HAVE_ENOUGH_DATA;
-    network_state_ = webkit_glue::WebMediaPlayer::LOADED;
+    // Since we have initialized the pipeline, say we have everything.
+    // TODO(hclam): change this to report the correct status.
+    ready_state_ = WebKit::WebMediaPlayer::HaveEnoughData;
+    network_state_ = WebKit::WebMediaPlayer::Loaded;
   } else {
     // TODO(hclam): should use pipeline_.GetError() to determine the state
     // properly and reports error using MediaError.
-    ready_state_ = webkit_glue::WebMediaPlayer::HAVE_NOTHING;
-    network_state_ = webkit_glue::WebMediaPlayer::NETWORK_ERROR;
+    ready_state_ = WebKit::WebMediaPlayer::HaveNothing;
+    network_state_ = WebKit::WebMediaPlayer::NetworkError;
   }
 
   PostTask(kNetworkStateTaskIndex,
-           &webkit_glue::WebMediaPlayer::NotifyNetworkStateChange);
+           &WebKit::WebMediaPlayerClient::networkStateChanged);
   PostTask(kReadyStateTaskIndex,
-           &webkit_glue::WebMediaPlayer::NotifyReadyStateChange);
+           &WebKit::WebMediaPlayerClient::readyStateChanged);
 }
 
-void WebMediaPlayerDelegateImpl::SetVideoRenderer(
-    VideoRendererImpl* video_renderer) {
+void WebMediaPlayerImpl::SetVideoRenderer(VideoRendererImpl* video_renderer) {
   video_renderer_ = video_renderer;
 }
 
-void WebMediaPlayerDelegateImpl::DidTask(CancelableTask* task) {
+void WebMediaPlayerImpl::DidTask(CancelableTask* task) {
   AutoLock auto_lock(task_lock_);
 
   for (size_t i = 0; i < tasks_.size(); ++i) {
@@ -358,7 +337,7 @@ void WebMediaPlayerDelegateImpl::DidTask(CancelableTask* task) {
   NOTREACHED();
 }
 
-void WebMediaPlayerDelegateImpl::CancelAllTasks() {
+void WebMediaPlayerImpl::CancelAllTasks() {
   AutoLock auto_lock(task_lock_);
   // Loop through the list of tasks and cancel tasks that are still alive.
   for (size_t i = 0; i < tasks_.size(); ++i) {
@@ -367,18 +346,18 @@ void WebMediaPlayerDelegateImpl::CancelAllTasks() {
   }
 }
 
-void WebMediaPlayerDelegateImpl::PostTask(int index,
-                                          WebMediaPlayerMethod method) {
+void WebMediaPlayerImpl::PostTask(int index,
+                                  WebMediaPlayerClientMethod method) {
   DCHECK(main_loop_);
 
   AutoLock auto_lock(task_lock_);
-  if(!tasks_[index]) {
+  if (!tasks_[index]) {
     CancelableTask* task = new NotifyWebMediaPlayerTask(this, method);
     tasks_[index] = task;
     main_loop_->PostTask(FROM_HERE, task);
   }
 }
 
-void WebMediaPlayerDelegateImpl::PostRepaintTask() {
-  PostTask(kRepaintTaskIndex, &webkit_glue::WebMediaPlayer::Repaint);
+void WebMediaPlayerImpl::PostRepaintTask() {
+  PostTask(kRepaintTaskIndex, &WebKit::WebMediaPlayerClient::repaint);
 }
diff --git a/chrome/renderer/webmediaplayer_delegate_impl.h b/chrome/renderer/webmediaplayer_impl.h
index 9ae5383..12c675f 100644
--- a/chrome/renderer/webmediaplayer_delegate_impl.h
+++ b/chrome/renderer/webmediaplayer_impl.h
@@ -1,8 +1,8 @@
-// Copyright (c) 2008 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.
+// Copyright (c) 2008-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.
 //
-// Delegate calls from WebCore::MediaPlayerPrivate to google's video player.
+// Delegate calls from WebCore::MediaPlayerPrivate to Chrome's video player.
 // It contains PipelineImpl which is the actual media player pipeline, it glues
 // the media player pipeline, data source, audio renderer and renderer.
 // PipelineImpl would creates multiple threads and access some public methods
@@ -40,19 +40,22 @@
 // at destruction of this class we will need to unhook it from destruction event
 // list of the main thread.
 
-#ifndef CHROME_RENDERER_WEBMEDIAPLAYER_DELEGATE_IMPL_H_
-#define CHROME_RENDERER_WEBMEDIAPLAYER_DELEGATE_IMPL_H_
+#ifndef CHROME_RENDERER_WEBMEDIAPLAYER_IMPL_H_
+#define CHROME_RENDERER_WEBMEDIAPLAYER_IMPL_H_
 
 #include <vector>
 
+#include "base/gfx/platform_canvas.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "media/base/filters.h"
 #include "media/base/pipeline_impl.h"
-#include "webkit/glue/webmediaplayer_delegate.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebMediaPlayer.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebMediaPlayerClient.h"
 
 class AudioRendererImpl;
 class DataSourceImpl;
+class GURL;
 class RenderView;
 class VideoRendererImpl;
 
@@ -60,103 +63,97 @@ namespace media {
 class FilterFactoryCollection;
 }
 
-// This typedef is used for WebMediaPlayerDelegateImpl::PostTask() and
+// This typedef is used for WebMediaPlayerImpl::PostTask() and
 // NotifyWebMediaPlayerTask in the source file.
-typedef void (webkit_glue::WebMediaPlayer::*WebMediaPlayerMethod)();
+typedef void (WebKit::WebMediaPlayerClient::*WebMediaPlayerClientMethod)();
 
-class WebMediaPlayerDelegateImpl : public webkit_glue::WebMediaPlayerDelegate,
-                                   public MessageLoop::DestructionObserver {
+class WebMediaPlayerImpl : public WebKit::WebMediaPlayer,
+                           public MessageLoop::DestructionObserver {
  public:
-  explicit WebMediaPlayerDelegateImpl(RenderView* view);
-  virtual ~WebMediaPlayerDelegateImpl();
+  WebMediaPlayerImpl(RenderView* view, WebKit::WebMediaPlayerClient* client);
+  virtual ~WebMediaPlayerImpl();
 
-  // Implementations of WebMediaPlayerDelegate, theses following methods are
-  // called from the WebKit, essentially lives inside the main thread.
-  virtual void Initialize(webkit_glue::WebMediaPlayer* media_player);
-
-  virtual void Load(const GURL& url);
-  virtual void CancelLoad();
+  virtual void load(const WebKit::WebURL& url);
+  virtual void cancelLoad();
 
   // Playback controls.
-  virtual void Play();
-  virtual void Pause();
-  virtual void Stop();
-  virtual void Seek(float seconds);
-  virtual void SetEndTime(float seconds);
-  virtual void SetPlaybackRate(float rate);
-  virtual void SetVolume(float volume);
-  virtual void SetVisible(bool visible);
-  virtual bool IsTotalBytesKnown();
+  virtual void play();
+  virtual void pause();
+  virtual void stop();
+  virtual void seek(float seconds);
+  virtual void setEndTime(float seconds);
+  virtual void setRate(float rate);
+  virtual void setVolume(float volume);
+  virtual void setVisible(bool visible);
+  virtual bool setAutoBuffer(bool autoBuffer);
+  virtual bool totalBytesKnown();
+  virtual float maxTimeBuffered() const;
+  virtual float maxTimeSeekable() const;
 
   // Methods for painting.
-  virtual void SetSize(const WebKit::WebSize& size);
+  virtual void setSize(const WebKit::WebSize& size);
 
-  virtual void Paint(skia::PlatformCanvas *canvas,
-                     const WebKit::WebRect& rect);
+  virtual void paint(WebKit::WebCanvas* canvas, const WebKit::WebRect& rect);
 
   // True if a video is loaded.
-  virtual bool IsVideo() const;
+  virtual bool hasVideo() const;
 
-  // Dimension of the video.
-  virtual size_t GetWidth() const;
-  virtual size_t GetHeight() const;
+  // Dimensions of the video.
+  virtual WebKit::WebSize naturalSize() const;
 
   // Getters of playback state.
-  virtual bool IsPaused() const;
-  virtual bool IsSeeking() const;
-  virtual float GetDuration() const;
-  virtual float GetCurrentTime() const;
-  virtual float GetPlayBackRate() const;
-  virtual float GetVolume() const;
-  virtual float GetMaxTimeBuffered() const;
-  virtual float GetMaxTimeSeekable() const;
+  virtual bool paused() const;
+  virtual bool seeking() const;
+  virtual float duration() const;
+  virtual float currentTime() const;
 
   // Get rate of loading the resource.
-  virtual int32 GetDataRate() const;
+  virtual int32 dataRate() const;
 
   // Internal states of loading and network.
   // TODO(hclam): Ask the pipeline about the state rather than having reading
   // them from members which would cause race conditions.
-  virtual webkit_glue::WebMediaPlayer::NetworkState GetNetworkState() const {
+  virtual WebKit::WebMediaPlayer::NetworkState networkState() const {
     return network_state_;
   }
-  virtual webkit_glue::WebMediaPlayer::ReadyState GetReadyState() const {
+  virtual WebKit::WebMediaPlayer::ReadyState readyState() const {
     return ready_state_;
   }
 
-  virtual int64 GetBytesLoaded() const;
-  virtual int64 GetTotalBytes() const;
+  virtual unsigned long long bytesLoaded() const;
+  virtual unsigned long long totalBytes() const;
 
-  // As we are closing the tab or even the browser, main_loop_ is destroyed
+  // As we are closing the tab or even the browser, |main_loop_| is destroyed
   // even before this object gets destructed, so we need to know when
-  // main_loop_ is being destroyed and we can stop posting repaint task
+  // |main_loop_| is being destroyed and we can stop posting repaint task
   // to it.
   virtual void WillDestroyCurrentMessageLoop();
 
-  // Callbacks.
+  // Notification callback for initialization from |pipeline_|. |successful| is
+  // true if the pipeline initialization is successful otherwise false.
   void DidInitializePipeline(bool successful);
 
-  // Called from tasks posted to main_loop_ from this object to remove
+  // Called from tasks posted to |main_loop_| from this object to remove
   // reference of them.
   void DidTask(CancelableTask* task);
 
   // Public methods to be called from renderers and data source so that
-  // WebMediaPlayerDelegateImpl has references to them.
+  // WebMediaPlayerImpl has references to them.
   void SetVideoRenderer(VideoRendererImpl* video_renderer);
 
-  // Called from VideoRenderer to fire a repaint task to main_loop_.
+  // Called from VideoRenderer to fire a repaint task to |main_loop_|.
   void PostRepaintTask();
 
   // Inline getters.
-  webkit_glue::WebMediaPlayer* web_media_player() { return web_media_player_; }
+  WebKit::WebMediaPlayerClient* client() { return client_; }
   RenderView* view() { return view_; }
 
  private:
   // Methods for posting tasks and cancelling tasks. This method may lives in
   // the main thread or the media threads.
-  void PostTask(int index, WebMediaPlayerMethod method);
+  void PostTask(int index, WebMediaPlayerClientMethod method);
 
-  // Cancel all tasks currently lives in |main_loop_|.
+  // Cancel all tasks currently live in |main_loop_|.
   void CancelAllTasks();
 
   // Indexes for tasks.
@@ -169,12 +166,12 @@ class WebMediaPlayerDelegateImpl : public webkit_glue::WebMediaPlayerDelegate,
   };
 
   // TODO(hclam): get rid of these members and read from the pipeline directly.
-  webkit_glue::WebMediaPlayer::NetworkState network_state_;
-  webkit_glue::WebMediaPlayer::ReadyState ready_state_;
+  WebKit::WebMediaPlayer::NetworkState network_state_;
+  WebKit::WebMediaPlayer::ReadyState ready_state_;
 
   // Message loops for posting tasks between Chrome's main thread. Also used
   // for DCHECKs so methods calls won't execute in the wrong thread.
-  MessageLoop* main_loop_;
+  MessageLoop* |main_loop_|;
 
   // A collection of factories for creating filters.
   scoped_refptr<media::FilterFactoryCollection> filter_factory_;
@@ -187,7 +184,7 @@ class WebMediaPlayerDelegateImpl : public webkit_glue::WebMediaPlayerDelegate,
   // from WebKit.
   scoped_refptr<VideoRendererImpl> video_renderer_;
 
-  webkit_glue::WebMediaPlayer* web_media_player_;
+  WebKit::WebMediaPlayerClient* client_;
   RenderView* view_;
 
   // List of tasks for holding pointers to all tasks currently in the
@@ -197,7 +194,7 @@ class WebMediaPlayerDelegateImpl : public webkit_glue::WebMediaPlayerDelegate,
   typedef std::vector<CancelableTask*> CancelableTaskList;
   CancelableTaskList tasks_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerDelegateImpl);
+  DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
-#endif  // ifndef CHROME_RENDERER_WEBMEDIAPLAYER_DELEGATE_IMPL_H_
+#endif  // CHROME_RENDERER_WEBMEDIAPLAYER_IMPL_H_