reflow comments in platform/fonts

third_party/WebKit/Source/platform/fonts/GlyphPageTreeNode.cpp

 /*
  * Copyright (C) 2006, 2007, 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 80 matching lines @@
        ++it)
     count += it->value->pageCount();
 
   if (m_systemFallbackChild)
     ++count;
 
   return count;
 }
 
 void GlyphPageTreeNode::pruneTreeCustomFontData(const FontData* fontData) {
-  // Enumerate all the roots and prune any tree that contains our custom font data.
+  // Enumerate all the roots and prune any tree that contains our custom font
+  // data.
   if (roots) {
     HashMap<int, GlyphPageTreeNode*>::iterator end = roots->end();
     for (HashMap<int, GlyphPageTreeNode*>::iterator it = roots->begin();
          it != end; ++it)
       it->value->pruneCustomFontData(fontData);
   }
 
   if (pageZeroRoot)
     pageZeroRoot->pruneCustomFontData(fontData);
 }
@@ skipping 64 matching lines @@
 
 void GlyphPageTreeNode::initializePurePage(const FontData* fontData,
                                            unsigned pageNumber) {
   ASSERT(m_level == 1);
 
   unsigned start = pageNumber * GlyphPage::size;
   UChar buffer[GlyphPage::size * 2 + 2];
   unsigned bufferLength;
   unsigned i;
 
-  // Fill in a buffer with the entire "page" of characters that we want to look up glyphs for.
+  // Fill in a buffer with the entire "page" of characters that we want to look
+  // up glyphs for.
   if (start < 0x10000) {
     bufferLength = GlyphPage::size;
     for (i = 0; i < GlyphPage::size; i++)
       buffer[i] = start + i;
 
     if (start == 0) {
       // Control characters must not render at all.
       for (i = 0; i < 0x20; ++i)
         buffer[i] = zeroWidthSpaceCharacter;
       for (i = 0x7F; i < 0xA0; i++)
@@ skipping 44 matching lines @@
     for (i = 0; i < GlyphPage::size; i++) {
       int c = i + start;
       buffer[i * 2] = U16_LEAD(c);
       buffer[i * 2 + 1] = U16_TRAIL(c);
     }
   }
 
   // Now that we have a buffer full of characters, we want to get back an array
   // of glyph indices.  This part involves calling into the platform-specific
   // routine of our glyph map for actually filling in the page with the glyphs.
-  // Success is not guaranteed. For example, Times fails to fill page 260, giving glyph data
-  // for only 128 out of 256 characters.
+  // Success is not guaranteed. For example, Times fails to fill page 260,
+  // giving glyph data for only 128 out of 256 characters.
   bool haveGlyphs;
   if (!fontData->isSegmented()) {
     m_page =
         GlyphPage::createForSingleFontData(this, toSimpleFontData(fontData));
     haveGlyphs = fill(m_page.get(), 0, GlyphPage::size, buffer, bufferLength,
                       toSimpleFontData(fontData));
   } else {
     m_page = GlyphPage::createForMixedFontData(this);
     haveGlyphs = false;
 
     const SegmentedFontData* segmentedFontData = toSegmentedFontData(fontData);
     for (int i = segmentedFontData->numFaces() - 1; i >= 0; i--) {
       RefPtr<FontDataForRangeSet> fontDataForRangeSet =
           segmentedFontData->faceAt(i);
       RefPtr<UnicodeRangeSet> ranges = fontDataForRangeSet->ranges();
       // If there are no ranges, that means this font should be used for
       // the full codepoint range, thus running the loop once over a
       // synthetic full UnicodeRange object. Otherwise we use the ranges
       // that come from the segmented font.  This needs a locally
       // initialized size_t variable (or a cast alternatively) as a
       // compile fix for Android since size_t differs between platforms.
       const size_t oneRoundForZeroRanges = 1u;
       for (size_t i = 0; i < max(ranges->size(), oneRoundForZeroRanges); ++i) {
         UnicodeRange range(0, kMaxCodepoint);
         if (ranges->size()) {
           range = ranges->rangeAt(i);
         }
-        // all this casting is to ensure all the parameters to min and max have the same type,
-        // to avoid ambiguous template parameter errors on Windows
+        // all this casting is to ensure all the parameters to min and max have
+        // the same type, to avoid ambiguous template parameter errors on
+        // Windows
         int from =
             max(0, static_cast<int>(range.from()) - static_cast<int>(start));
         int to = 1 + min(static_cast<int>(range.to()) - static_cast<int>(start),
                          static_cast<int>(GlyphPage::size) - 1);
         if (from >= static_cast<int>(GlyphPage::size) || to <= 0)
           continue;
 
         // If this is a custom font needs to be loaded, do not fill
         // the page so that font fallback is used while loading.
         RefPtr<CustomFontData> customData =
@@ skipping 114 matching lines @@
     return;
 
   // Prune any branch that contains this FontData.
   if (std::unique_ptr<GlyphPageTreeNode> node = m_children.take(fontData)) {
     if (unsigned customFontCount = node->m_customFontCount + 1) {
       for (GlyphPageTreeNode* curr = this; curr; curr = curr->m_parent)
         curr->m_customFontCount -= customFontCount;
     }
   }
 
-  // Check any branches that remain that still have custom fonts underneath them.
+  // Check any branches that remain that still have custom fonts underneath
+  // them.
   if (!m_customFontCount)
     return;
 
   GlyphPageTreeNodeMap::iterator end = m_children.end();
   for (GlyphPageTreeNodeMap::iterator it = m_children.begin(); it != end; ++it)
     it->value->pruneCustomFontData(fontData);
 }
 
 void GlyphPageTreeNode::pruneFontData(const SimpleFontData* fontData,
                                       unsigned level) {
@@ skipping 45 matching lines @@
   // System fallback page is initialized with the parent's page, as individual
   // entries may use different fonts depending on character. If the Font
   // ever finds it needs a glyph out of the system fallback page, it will
   // ask the system for the best font to use and fill that glyph in for us.
   if (GlyphPage* parentPage = m_parent->page())
     return parentPage->createCopiedSystemFallbackPage(this);
   return GlyphPage::createForMixedFontData(this);
 }
 
 }  // namespace blink