Remove MEDIA_SOURCE feature define.

Source/WebCore/platform/graphics/MediaPlayer.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 18 matching lines @@
 #include "MediaPlayer.h"
 
 #include "ContentType.h"
 #include "Document.h"
 #include "Frame.h"
 #include "FrameView.h"
 #include "IntRect.h"
 #include "Logging.h"
 #include "MIMETypeRegistry.h"
 #include "MediaPlayerPrivate.h"
+#include "MediaSource.h"
 #include "Settings.h"
 #include "TimeRanges.h"
 #include <wtf/text/CString.h>
 
 #if ENABLE(VIDEO_TRACK)
 #include "InbandTextTrackPrivate.h"
 #endif
 
-#if ENABLE(MEDIA_SOURCE)
-#include "MediaSource.h"
-#endif
-
 #if PLATFORM(QT)
 #include <QtGlobal>
 #endif
 
 #if USE(GSTREAMER)
 #include "MediaPlayerPrivateGStreamer.h"
 #define PlatformMediaEngineClassName MediaPlayerPrivateGStreamer
 #endif
 
 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
@@ skipping 27 matching lines @@
 
 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
 
 // a null player to make MediaPlayer logic simpler
 
 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
 public:
     NullMediaPlayerPrivate(MediaPlayer*) { }
 
     virtual void load(const String&) { }
-#if ENABLE(MEDIA_SOURCE)
     virtual void load(const String&, PassRefPtr<MediaSource>) { }
-#endif
     virtual void cancelLoad() { }
 
     virtual void prepareToPlay() { }
     virtual void play() { }
     virtual void pause() { }    
 
     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
 #if USE(ACCELERATED_COMPOSITING)
     virtual PlatformLayer* platformLayer() const { return 0; }
 #endif
@@ skipping 250 matching lines @@
     m_mediaPlayerClient = 0;
 }
 
 bool MediaPlayer::load(const KURL& url, const ContentType& contentType, const String& keySystem)
 {
     m_contentMIMEType = contentType.type().lower();
     m_contentTypeCodecs = contentType.parameter(codecs());
     m_url = url;
     m_keySystem = keySystem.lower();
     m_contentMIMETypeWasInferredFromExtension = false;
-
-#if ENABLE(MEDIA_SOURCE)
     m_mediaSource = 0;
-#endif
 
     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
     if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
         if (m_url.protocolIsData())
             m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
         else {
             String lastPathComponent = url.lastPathComponent();
             size_t pos = lastPathComponent.reverseFind('.');
             if (pos != notFound) {
                 String extension = lastPathComponent.substring(pos + 1);
                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
                 if (!mediaType.isEmpty()) {
                     m_contentMIMEType = mediaType;
                     m_contentMIMETypeWasInferredFromExtension = true;
                 }
             }
         }
     }
 
     loadWithNextMediaEngine(0);
     return m_currentMediaEngine;
 }
 
-#if ENABLE(MEDIA_SOURCE)
 bool MediaPlayer::load(const KURL& url, PassRefPtr<MediaSource> mediaSource)
 {
     m_mediaSource = mediaSource;
     m_contentMIMEType = "";
     m_contentTypeCodecs = "";
     m_url = url;
     m_keySystem = "";
     m_contentMIMETypeWasInferredFromExtension = false;
     loadWithNextMediaEngine(0);
     return m_currentMediaEngine;
 }
-#endif
 
 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
 {
     MediaPlayerFactory* engine = 0;
 
     if (!m_contentMIMEType.isEmpty())
         engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_url, current);
 
     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
     if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
@@ skipping 13 matching lines @@
         m_private->setMediaPlayerProxy(m_playerProxy);
 #endif
         m_private->setPrivateBrowsingMode(m_privateBrowsing);
         m_private->setPreload(m_preload);
         m_private->setPreservesPitch(preservesPitch());
         if (m_shouldPrepareToRender)
             m_private->prepareForRendering();
     }
 
     if (m_private) {
-#if ENABLE(MEDIA_SOURCE)
         if (m_mediaSource)
             m_private->load(m_url.string(), m_mediaSource);
         else
-#endif
-        m_private->load(m_url.string());
+            m_private->load(m_url.string());
     } else {
         m_private = createNullMediaPlayer(this);
         if (m_mediaPlayerClient) {
             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
             m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
         }
     }
 }
 
 bool MediaPlayer::hasAvailableVideoFrame() const
@@ skipping 690 matching lines @@
     if (!m_private)
         return;
 
     m_private->simulateAudioInterruption();
 }
 #endif
 
 }
 
 #endif