src/third_party/WebKit/Source/core/css/CSSFontFace.cpp

   1 /*
   2  * Copyright (C) 2007, 2008, 2011 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/CSSFontFace.h"
  28
  29 #include "core/css/CSSFontFaceSource.h"
  30 #include "core/css/CSSFontSelector.h"
  31 #include "core/css/CSSSegmentedFontFace.h"
  32 #include "core/css/FontFaceSet.h"
  33 #include "core/css/RemoteFontFaceSource.h"
  34 #include "core/frame/UseCounter.h"
  35 #include "platform/fonts/FontDescription.h"
  36 #include "platform/fonts/SimpleFontData.h"
  37
  38 namespace blink {
  39
  40 void CSSFontFace::addSource(PassOwnPtrWillBeRawPtr<CSSFontFaceSource> source)
  41 {
  42     source->setFontFace(this);
  43     m_sources.append(source);
  44 }
  45
  46 void CSSFontFace::setSegmentedFontFace(CSSSegmentedFontFace* segmentedFontFace)
  47 {
  48     ASSERT(!m_segmentedFontFace);
  49     m_segmentedFontFace = segmentedFontFace;
  50 }
  51
  52 void CSSFontFace::didBeginLoad()
  53 {
  54     if (loadStatus() == FontFace::Unloaded)
  55         setLoadStatus(FontFace::Loading);
  56 }
  57
  58 void CSSFontFace::fontLoaded(RemoteFontFaceSource* source)
  59 {
  60     if (!isValid() || source != m_sources.first())
  61         return;
  62
  63     if (loadStatus() == FontFace::Loading) {
  64         if (source->ensureFontData()) {
  65             setLoadStatus(FontFace::Loaded);
  66 #if ENABLE(SVG_FONTS)
  67             Document* document = m_segmentedFontFace ? m_segmentedFontFace->fontSelector()->document() : 0;
  68             if (document && source->isSVGFontFaceSource())
  69                 UseCounter::count(*document, UseCounter::SVGFontInCSS);
  70 #endif
  71         } else {
  72             m_sources.removeFirst();
  73             load();
  74         }
  75     }
  76
  77     if (m_segmentedFontFace)
  78         m_segmentedFontFace->fontLoaded(this);
  79 }
  80
  81 void CSSFontFace::fontLoadWaitLimitExceeded(RemoteFontFaceSource* source)
  82 {
  83     if (!isValid() || source != m_sources.first())
  84         return;
  85     if (m_segmentedFontFace)
  86         m_segmentedFontFace->fontLoadWaitLimitExceeded(this);
  87 }
  88
  89 PassRefPtr<SimpleFontData> CSSFontFace::getFontData(const FontDescription& fontDescription)
  90 {
  91     if (!isValid())
  92         return nullptr;
  93
  94     while (!m_sources.isEmpty()) {
  95         OwnPtrWillBeMember<CSSFontFaceSource>& source = m_sources.first();
  96         if (RefPtr<SimpleFontData> result = source->getFontData(fontDescription)) {
  97             if (loadStatus() == FontFace::Unloaded && (source->isLoading() || source->isLoaded()))
  98                 setLoadStatus(FontFace::Loading);
  99             if (loadStatus() == FontFace::Loading && source->isLoaded())
 100                 setLoadStatus(FontFace::Loaded);
 101             return result.release();
 102         }
 103         m_sources.removeFirst();
 104     }
 105
 106     if (loadStatus() == FontFace::Unloaded)
 107         setLoadStatus(FontFace::Loading);
 108     if (loadStatus() == FontFace::Loading)
 109         setLoadStatus(FontFace::Error);
 110     return nullptr;
 111 }
 112
 113 bool CSSFontFace::maybeScheduleFontLoad(const FontDescription& fontDescription, UChar32 character)
 114 {
 115     if (m_ranges.contains(character)) {
 116         if (loadStatus() == FontFace::Unloaded)
 117             load(fontDescription);
 118         return true;
 119     }
 120     return false;
 121 }
 122
 123 void CSSFontFace::load()
 124 {
 125     FontDescription fontDescription;
 126     FontFamily fontFamily;
 127     fontFamily.setFamily(m_fontFace->family());
 128     fontDescription.setFamily(fontFamily);
 129     fontDescription.setTraits(m_fontFace->traits());
 130     load(fontDescription);
 131 }
 132
 133 void CSSFontFace::load(const FontDescription& fontDescription)
 134 {
 135     if (loadStatus() == FontFace::Unloaded)
 136         setLoadStatus(FontFace::Loading);
 137     ASSERT(loadStatus() == FontFace::Loading);
 138
 139     while (!m_sources.isEmpty()) {
 140         OwnPtrWillBeMember<CSSFontFaceSource>& source = m_sources.first();
 141         if (source->isValid()) {
 142             if (source->isLocal()) {
 143                 if (source->isLocalFontAvailable(fontDescription)) {
 144                     setLoadStatus(FontFace::Loaded);
 145                     return;
 146                 }
 147             } else {
 148                 if (!source->isLoaded())
 149                     source->beginLoadIfNeeded();
 150                 else
 151                     setLoadStatus(FontFace::Loaded);
 152                 return;
 153             }
 154         }
 155         m_sources.removeFirst();
 156     }
 157     setLoadStatus(FontFace::Error);
 158 }
 159
 160 void CSSFontFace::setLoadStatus(FontFace::LoadStatus newStatus)
 161 {
 162     ASSERT(m_fontFace);
 163     if (newStatus == FontFace::Error)
 164         m_fontFace->setError();
 165     else
 166         m_fontFace->setLoadStatus(newStatus);
 167
 168     if (!m_segmentedFontFace)
 169         return;
 170     Document* document = m_segmentedFontFace->fontSelector()->document();
 171     if (!document)
 172         return;
 173
 174     switch (newStatus) {
 175     case FontFace::Loading:
 176         FontFaceSet::from(*document)->beginFontLoading(m_fontFace);
 177         break;
 178     case FontFace::Loaded:
 179         FontFaceSet::from(*document)->fontLoaded(m_fontFace);
 180         break;
 181     case FontFace::Error:
 182         FontFaceSet::from(*document)->loadError(m_fontFace);
 183         break;
 184     default:
 185         break;
 186     }
 187 }
 188
 189 CSSFontFace::UnicodeRangeSet::UnicodeRangeSet(const Vector<UnicodeRange>& ranges)
 190     : m_ranges(ranges)
 191 {
 192     if (m_ranges.isEmpty())
 193         return;
 194
 195     std::sort(m_ranges.begin(), m_ranges.end());
 196
 197     // Unify overlapping ranges.
 198     UChar32 from = m_ranges[0].from();
 199     UChar32 to = m_ranges[0].to();
 200     size_t targetIndex = 0;
 201     for (size_t i = 1; i < m_ranges.size(); i++) {
 202         if (to + 1 >= m_ranges[i].from()) {
 203             to = std::max(to, m_ranges[i].to());
 204         } else {
 205             m_ranges[targetIndex++] = UnicodeRange(from, to);
 206             from = m_ranges[i].from();
 207             to = m_ranges[i].to();
 208         }
 209     }
 210     m_ranges[targetIndex++] = UnicodeRange(from, to);
 211     m_ranges.shrink(targetIndex);
 212 }
 213
 214 bool CSSFontFace::UnicodeRangeSet::contains(UChar32 c) const
 215 {
 216     if (isEntireRange())
 217         return true;
 218     Vector<UnicodeRange>::const_iterator it = std::lower_bound(m_ranges.begin(), m_ranges.end(), c);
 219     return it != m_ranges.end() && it->contains(c);
 220 }
 221
 222 bool CSSFontFace::UnicodeRangeSet::intersectsWith(const String& text) const
 223 {
 224     if (text.isEmpty())
 225         return false;
 226     if (isEntireRange())
 227         return true;
 228     if (text.is8Bit() && m_ranges[0].from() >= 0x100)
 229         return false;
 230
 231     unsigned index = 0;
 232     while (index < text.length()) {
 233         UChar32 c = text.characterStartingAt(index);
 234         index += U16_LENGTH(c);
 235         if (contains(c))
 236             return true;
 237     }
 238     return false;
 239 }
 240
 241 void CSSFontFace::trace(Visitor* visitor)
 242 {
 243     visitor->trace(m_segmentedFontFace);
 244     visitor->trace(m_sources);
 245     visitor->trace(m_fontFace);
 246 }
 247
 248 }