Eliminate MediaPlayer abstraction(network state)

Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 851 matching lines @@
     // 5 - Queue a task to fire a simple event named loadstart at the media element.
     scheduleEvent(EventTypeNames::loadstart);
 
     // 6 - If mode is attribute, then run these substeps
     if (mode == attribute) {
         m_loadState = LoadingFromSrcAttr;
 
         // If the src attribute's value is the empty string ... jump down to the failed step below
         KURL mediaURL = getNonEmptyURLAttribute(srcAttr);
         if (mediaURL.isEmpty()) {
-            mediaLoadingFailed(MediaPlayer::FormatError);
+            mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
             WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, empty 'src'");
             return;
         }
 
         if (!isSafeToLoadURL(mediaURL, Complain)) {
-            mediaLoadingFailed(MediaPlayer::FormatError);
+            mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
             return;
         }
 
         // No type or key system information is available when the url comes
         // from the 'src' attribute so MediaPlayer
         // will have to pick a media engine based on the file extension.
         ContentType contentType((String()));
         loadResource(mediaURL, contentType, String());
         WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, using 'src' attribute url");
         return;
@@ skipping 21 matching lines @@
 }
 
 void HTMLMediaElement::loadResource(const KURL& url, ContentType& contentType, const String& keySystem)
 {
     ASSERT(isSafeToLoadURL(url, Complain));
 
     WTF_LOG(Media, "HTMLMediaElement::loadResource(%s, %s, %s)", urlForLoggingMedia(url).utf8().data(), contentType.raw().utf8().data(), keySystem.utf8().data());
 
     LocalFrame* frame = document().frame();
     if (!frame) {
-        mediaLoadingFailed(MediaPlayer::FormatError);
+        mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
     m_networkState = NETWORK_LOADING;
 
     // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
     // cache is an internal detail not exposed through the media element API.
     m_currentSrc = url;
 
@@ skipping 35 matching lines @@
     if (attemptLoad && canLoadURL(url, contentType, keySystem)) {
         ASSERT(!webMediaPlayer());
 
         if (!m_havePreparedToPlay && !autoplay() && m_preload == MediaPlayer::None) {
             WTF_LOG(Media, "HTMLMediaElement::loadResource : Delaying load because preload == 'none'");
             deferLoad();
         } else {
             startPlayerLoad();
         }
     } else {
-        mediaLoadingFailed(MediaPlayer::FormatError);
+        mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     }
 
     // If there is no poster to display, allow the media engine to render video frames as soon as
     // they are available.
     updateDisplayState();
 
     if (renderer())
         renderer()->updateFromElement();
 }
 
@@ skipping 632 matching lines @@
 {
     WTF_LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks");
     m_asyncEventQueue->cancelAllEvents();
 
     for (HTMLSourceElement* source = Traversal<HTMLSourceElement>::firstChild(*this); source; source = Traversal<HTMLSourceElement>::nextSibling(*source))
         source->cancelPendingErrorEvent();
 }
 
 void HTMLMediaElement::mediaPlayerNetworkStateChanged()
 {
-    setNetworkState(m_player->networkState());
+    setNetworkState(webMediaPlayer()->networkState());

[philipj_slow, 2014/07/12 20:50:55]

You should also be able to remove
MediaPlayerClient::mediaPlayerNetworkStateChanged() now.

[Srirama, 2014/07/13 05:30:17]

But that is not straightforward, it can be done only when we make
HTMLMediaElement implement webmediaplayerclient.

 }
 
-void HTMLMediaElement::mediaLoadingFailed(MediaPlayer::NetworkState error)
+void HTMLMediaElement::mediaLoadingFailed(WebMediaPlayer::NetworkState error)
 {
     stopPeriodicTimers();
 
     // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
     // <source> children, schedule the next one
     if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
 
         // resource selection algorithm
         // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM manipulation task source, to fire a simple event named error at the candidate element.
         if (m_currentSourceNode)
@@ skipping 10 matching lines @@
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState - scheduling next <source>");
             scheduleNextSourceChild();
         } else {
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState - no more <source> elements, waiting");
             waitForSourceChange();
         }
 
         return;
     }
 
-    if (error == MediaPlayer::NetworkError && m_readyState >= HAVE_METADATA)
+    if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= HAVE_METADATA)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
-    else if (error == MediaPlayer::DecodeError)
+    else if (error == WebMediaPlayer::NetworkStateDecodeError)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));
-    else if ((error == MediaPlayer::FormatError || error == MediaPlayer::NetworkError) && m_loadState == LoadingFromSrcAttr)
+    else if ((error == WebMediaPlayer::NetworkStateFormatError
+        || error == WebMediaPlayer::NetworkStateNetworkError)
+        && m_loadState == LoadingFromSrcAttr)
         noneSupported();
 
     updateDisplayState();
     if (hasMediaControls())
         mediaControls()->reset();
 }
 
-void HTMLMediaElement::setNetworkState(MediaPlayer::NetworkState state)
+void HTMLMediaElement::setNetworkState(WebMediaPlayer::NetworkState state)
 {
     WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%d) - current state is %d", static_cast<int>(state), static_cast<int>(m_networkState));
 
-    if (state == MediaPlayer::Empty) {
+    if (state == WebMediaPlayer::NetworkStateEmpty) {
         // Just update the cached state and leave, we can't do anything.
         m_networkState = NETWORK_EMPTY;
         return;
     }
 
-    if (state == MediaPlayer::FormatError || state == MediaPlayer::NetworkError || state == MediaPlayer::DecodeError) {
+    if (state == WebMediaPlayer::NetworkStateFormatError
+        || state == WebMediaPlayer::NetworkStateNetworkError
+        || state == WebMediaPlayer::NetworkStateDecodeError) {
         mediaLoadingFailed(state);
         return;
     }
 
-    if (state == MediaPlayer::Idle) {
+    if (state == WebMediaPlayer::NetworkStateIdle) {
         if (m_networkState > NETWORK_IDLE) {
             changeNetworkStateFromLoadingToIdle();
             setShouldDelayLoadEvent(false);
         } else {
             m_networkState = NETWORK_IDLE;
         }
     }
 
-    if (state == MediaPlayer::Loading) {
+    if (state == WebMediaPlayer::NetworkStateLoading) {
         if (m_networkState < NETWORK_LOADING || m_networkState == NETWORK_NO_SOURCE)
             startProgressEventTimer();
         m_networkState = NETWORK_LOADING;
     }
 
-    if (state == MediaPlayer::Loaded) {
+    if (state == WebMediaPlayer::NetworkStateLoaded) {
         if (m_networkState != NETWORK_IDLE)
             changeNetworkStateFromLoadingToIdle();
         m_completelyLoaded = true;
     }
 }
 
 void HTMLMediaElement::changeNetworkStateFromLoadingToIdle()
 {
     ASSERT(m_player);
     m_progressEventTimer.stop();
@@ skipping 2253 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(0);
 }
 #endif
 
 }