Flesh out more of ChromiumBridge.cpp eliminating all but two methods on...

webkit/api/src/WebMediaPlayerClientImpl.cpp

 // 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 "config.h"
 #include "WebMediaPlayerClientImpl.h"
 
 #if ENABLE(VIDEO)
 
-#include "TimeRanges.h"
 #include "WebCanvas.h"
 #include "WebCString.h"
+#include "WebFrameClient.h"
+#include "WebFrameImpl.h"
 #include "WebKit.h"
 #include "WebKitClient.h"
 #include "WebMediaPlayer.h"
 #include "WebMimeRegistry.h"
 #include "WebRect.h"
 #include "WebSize.h"
 #include "WebString.h"
 #include "WebURL.h"
 
 #include "CString.h"
 #include "Frame.h"
 #include "GraphicsContext.h"
 #include "HTMLMediaElement.h"
 #include "IntSize.h"
 #include "KURL.h"
 #include "MediaPlayer.h"
 #include "NotImplemented.h"
+#include "TimeRanges.h"
 #include <wtf/Assertions.h>
 
 #if WEBKIT_USING_SKIA
 #include "PlatformContextSkia.h"
 #endif
 
 using namespace WebCore;
 
 namespace WebKit {
 
+static WebMediaPlayer* createWebMediaPlayer(
+    WebMediaPlayerClient* client, Frame* frame)
+{
+    WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
+    if (!webFrame->client())
+        return 0;
+    return webFrame->client()->createMediaPlayer(webFrame, client);
+}
+
 bool WebMediaPlayerClientImpl::m_isEnabled = false;
 
 bool WebMediaPlayerClientImpl::isEnabled()
 {
     return m_isEnabled;
 }
 
 void WebMediaPlayerClientImpl::setIsEnabled(bool isEnabled)
 {
     m_isEnabled = isEnabled;
 }
 
 void WebMediaPlayerClientImpl::registerSelf(MediaEngineRegistrar registrar)
 {
     if (m_isEnabled) {
         registrar(WebMediaPlayerClientImpl::create,
                   WebMediaPlayerClientImpl::getSupportedTypes,
                   WebMediaPlayerClientImpl::supportsType);
     }
 }
 
-
 // WebMediaPlayerClient --------------------------------------------------------
 
 void WebMediaPlayerClientImpl::networkStateChanged()
 {
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->networkStateChanged();
 }
 
 void WebMediaPlayerClientImpl::readyStateChanged()
 {
@@ skipping 42 matching lines @@
     ASSERT(m_mediaPlayer);
     m_mediaPlayer->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_mediaPlayer);
 }
 
 // MediaPlayerPrivateInterface -------------------------------------------------
 
 void WebMediaPlayerClientImpl::load(const String& url)
 {
     Frame* frame = static_cast<HTMLMediaElement*>(
         m_mediaPlayer->mediaPlayerClient())->document()->frame();
-    m_webMediaPlayer.set(webKitClient()->createWebMediaPlayer(this, frame));
+    m_webMediaPlayer.set(createWebMediaPlayer(this, frame));
     if (m_webMediaPlayer.get())
         m_webMediaPlayer->load(KURL(ParsedURLString, url));
 }
 
 void WebMediaPlayerClientImpl::cancelLoad()
 {
     if (m_webMediaPlayer.get())
         m_webMediaPlayer->cancelLoad();
 }
 
@@ skipping 116 matching lines @@
     return MediaPlayer::HaveNothing;
 }
 
 float WebMediaPlayerClientImpl::maxTimeSeekable() const
 {
     if (m_webMediaPlayer.get())
         return m_webMediaPlayer->maxTimeSeekable();
     return 0.0f;
 }
 
-WTF::PassRefPtr<WebCore::TimeRanges> WebMediaPlayerClientImpl::buffered() const
+PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const
 {
     if (m_webMediaPlayer.get()) {
         const WebTimeRanges& webRanges = m_webMediaPlayer->buffered();
 
         // FIXME: Save the time ranges in a member variable and update it when needed.
-        WTF::RefPtr<TimeRanges> ranges = TimeRanges::create();
+        RefPtr<TimeRanges> ranges = TimeRanges::create();
         for (size_t i = 0; i < webRanges.size(); ++i)
             ranges->add(webRanges[i].start, webRanges[i].end);
         return ranges.release();
     }
     return TimeRanges::create();
 }
 
 int WebMediaPlayerClientImpl::dataRate() const
 {
     if (m_webMediaPlayer.get())
@@ skipping 98 matching lines @@
 }
 
 WebMediaPlayerClientImpl::WebMediaPlayerClientImpl()
     : m_mediaPlayer(0)
 {
 }
 
 } // namespace WebKit
 
 #endif  // ENABLE(VIDEO)