Removing a bunch of unused platform code.

Source/WebCore/loader/archive/ArchiveFactory.cpp

 /*
  * Copyright (C) 2008 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
@@ skipping 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "ArchiveFactory.h"
 
+#include "MIMETypeRegistry.h"
+
+#if USE(CF) && ENABLE(WEB_ARCHIVE)

[eae, 2013/04/05 22:28:53]

Where did this come from?

[Nate Chapin, 2013/04/05 22:31:03]

I removed these ifdefs a few hours ago, must be a bad merge.

+#include "LegacyWebArchive.h"
+#endif
+#if ENABLE(MHTML)
 #include "MHTMLArchive.h"
-#include "MIMETypeRegistry.h"
+#endif
 
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
 typedef PassRefPtr<Archive> RawDataCreationFunction(const KURL&, SharedBuffer*);
 typedef HashMap<String, RawDataCreationFunction*, CaseFoldingHash> ArchiveMIMETypesMap;
 
 // The create functions in the archive classes return PassRefPtr to concrete subclasses
 // of Archive. This adaptor makes the functions have a uniform return type.
 template <typename ArchiveClass> static PassRefPtr<Archive> archiveFactoryCreate(const KURL& url, SharedBuffer* buffer)
 {
     return ArchiveClass::create(url, buffer);
 }
 
 static ArchiveMIMETypesMap& archiveMIMETypes()
 {
     DEFINE_STATIC_LOCAL(ArchiveMIMETypesMap, mimeTypes, ());
     static bool initialized = false;
 
     if (initialized)
         return mimeTypes;
 
+#if ENABLE(WEB_ARCHIVE) && USE(CF)
+    mimeTypes.set("application/x-webarchive", archiveFactoryCreate<LegacyWebArchive>);
+#endif
+#if ENABLE(MHTML)
     mimeTypes.set("multipart/related", archiveFactoryCreate<MHTMLArchive>);
+#endif
 
     initialized = true;
     return mimeTypes;
 }
 
 bool ArchiveFactory::isArchiveMimeType(const String& mimeType)
 {
     return !mimeType.isEmpty() && archiveMIMETypes().contains(mimeType);
 }
 
 PassRefPtr<Archive> ArchiveFactory::create(const KURL& url, SharedBuffer* data, const String& mimeType)
 {
     RawDataCreationFunction* function = mimeType.isEmpty() ? 0 : archiveMIMETypes().get(mimeType);
     return function ? function(url, data) : PassRefPtr<Archive>(0);
 }
 
 void ArchiveFactory::registerKnownArchiveMIMETypes()
 {
     HashSet<String>& mimeTypes = MIMETypeRegistry::getSupportedNonImageMIMETypes();
     ArchiveMIMETypesMap::iterator i = archiveMIMETypes().begin();
     ArchiveMIMETypesMap::iterator end = archiveMIMETypes().end();
 
     for (; i != end; ++i)
         mimeTypes.add(i->key);
 }
 
 }