1 /* 2 * Copyright (C) 2007, 2010 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "config.h" 27 #include "core/css/CSSFontFaceSrcValue.h" 28 29 #include "core/FetchInitiatorTypeNames.h" 30 #include "core/css/StyleSheetContents.h" 31 #include "core/dom/Document.h" 32 #include "core/dom/Node.h" 33 #include "core/fetch/FetchRequest.h" 34 #include "core/fetch/FontResource.h" 35 #include "core/fetch/ResourceFetcher.h" 36 #include "core/svg/SVGFontFaceElement.h" 37 #include "platform/fonts/FontCustomPlatformData.h" 38 #include "wtf/text/StringBuilder.h" 39 40 namespace WebCore { 41 42 #if ENABLE(SVG_FONTS) 43 bool CSSFontFaceSrcValue::isSVGFontFaceSrc() const 44 { 45 return equalIgnoringCase(m_format, "svg"); 46 } 47 #endif 48 49 bool CSSFontFaceSrcValue::isSupportedFormat() const 50 { 51 // Normally we would just check the format, but in order to avoid conflicts with the old WinIE style of font-face, 52 // we will also check to see if the URL ends with .eot. If so, we'll go ahead and assume that we shouldn't load it. 53 if (m_format.isEmpty()) { 54 // Check for .eot. 55 if (!m_resource.startsWith("data:", false) && m_resource.endsWith(".eot", false)) 56 return false; 57 return true; 58 } 59 60 return FontCustomPlatformData::supportsFormat(m_format) 61 #if ENABLE(SVG_FONTS) 62 || isSVGFontFaceSrc() 63 #endif 64 ; 65 } 66 67 String CSSFontFaceSrcValue::customCSSText() const 68 { 69 StringBuilder result; 70 if (isLocal()) 71 result.appendLiteral("local("); 72 else 73 result.appendLiteral("url("); 74 result.append(m_resource); 75 result.append(')'); 76 if (!m_format.isEmpty()) { 77 result.appendLiteral(" format("); 78 result.append(m_format); 79 result.append(')'); 80 } 81 return result.toString(); 82 } 83 84 bool CSSFontFaceSrcValue::hasFailedOrCanceledSubresources() const 85 { 86 if (!m_fetched) 87 return false; 88 return m_fetched->loadFailedOrCanceled(); 89 } 90 91 bool CSSFontFaceSrcValue::shouldSetCrossOriginAccessControl(const KURL& resource, SecurityOrigin* securityOrigin) 92 { 93 if (resource.isLocalFile() || resource.protocolIsData()) 94 return false; 95 return !securityOrigin->canRequest(resource); 96 } 97 98 FontResource* CSSFontFaceSrcValue::fetch(Document* document) 99 { 100 if (!m_fetched) { 101 FetchRequest request(ResourceRequest(document->completeURL(m_resource)), FetchInitiatorTypeNames::css); 102 SecurityOrigin* securityOrigin = document->securityOrigin(); 103 if (shouldSetCrossOriginAccessControl(request.url(), securityOrigin)) { 104 request.setCrossOriginAccessControl(securityOrigin, DoNotAllowStoredCredentials); 105 } 106 request.mutableResourceRequest().setHTTPReferrer(m_referrer); 107 m_fetched = document->fetcher()->fetchFont(request); 108 } else { 109 // FIXME: CSSFontFaceSrcValue::fetch is invoked when @font-face rule 110 // is processed by StyleResolver / StyleEngine. 111 restoreCachedResourceIfNeeded(document); 112 } 113 return m_fetched.get(); 114 } 115 116 void CSSFontFaceSrcValue::restoreCachedResourceIfNeeded(Document* document) 117 { 118 ASSERT(m_fetched); 119 ASSERT(document && document->fetcher()); 120 121 const String resourceURL = document->completeURL(m_resource); 122 if (document->fetcher()->cachedResource(KURL(ParsedURLString, resourceURL))) 123 return; 124 125 FetchRequest request(ResourceRequest(resourceURL), FetchInitiatorTypeNames::css); 126 document->fetcher()->requestLoadStarted(m_fetched.get(), request, ResourceFetcher::ResourceLoadingFromCache); 127 } 128 129 bool CSSFontFaceSrcValue::equals(const CSSFontFaceSrcValue& other) const 130 { 131 return m_isLocal == other.m_isLocal && m_format == other.m_format && m_resource == other.m_resource; 132 } 133 134 } 135