reflow comments in platform/fonts

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 81 matching lines @@
          (m_fontFallbackList ? m_fontFallbackList->fontSelectorVersion() : 0) ==
              (other.m_fontFallbackList
                   ? other.m_fontFallbackList->fontSelectorVersion()
                   : 0) &&
          (m_fontFallbackList ? m_fontFallbackList->generation() : 0) ==
              (other.m_fontFallbackList ? other.m_fontFallbackList->generation()
                                        : 0);
 }
 
 void Font::update(FontSelector* fontSelector) const {
-  // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up
-  // being reasonably safe (because inherited fonts in the render tree pick up the new
-  // style anyway. Other copies are transient, e.g., the state in the GraphicsContext, and
-  // won't stick around long enough to get you in trouble). Still, this is pretty disgusting,
-  // and could eventually be rectified by using RefPtrs for Fonts themselves.
+  // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr,
+  // but it ends up being reasonably safe (because inherited fonts in the render
+  // tree pick up the new style anyway. Other copies are transient, e.g., the
+  // state in the GraphicsContext, and won't stick around long enough to get you
+  // in trouble). Still, this is pretty disgusting, and could eventually be
+  // rectified by using RefPtrs for Fonts themselves.
   if (!m_fontFallbackList)
     m_fontFallbackList = FontFallbackList::create();
   m_fontFallbackList->invalidate(fontSelector);
 }
 
 float Font::buildGlyphBuffer(const TextRunPaintInfo& runInfo,
                              GlyphBuffer& glyphBuffer,
                              const GlyphData* emphasisData) const {
   if (codePath(runInfo) == ComplexPath) {
     float width;
@@ skipping 10 matching lines @@
     return width;
   }
 
   SimpleShaper shaper(this, runInfo.run, emphasisData,
                       nullptr /* fallbackFonts */, nullptr);
   shaper.advance(runInfo.from);
   shaper.advance(runInfo.to, &glyphBuffer);
   float width = shaper.runWidthSoFar();
 
   if (runInfo.run.rtl()) {
-    // Glyphs are shaped & stored in RTL advance order - reverse them for LTR drawing.
+    // Glyphs are shaped & stored in RTL advance order - reverse them for LTR
+    // drawing.
     shaper.advance(runInfo.run.length());
     glyphBuffer.reverseForSimpleRTL(width, shaper.runWidthSoFar());
   }
 
   return width;
 }
 
 bool Font::drawText(SkCanvas* canvas,
                     const TextRunPaintInfo& runInfo,
                     const FloatPoint& point,
                     float deviceScaleFactor,
                     const SkPaint& paint) const {
-  // Don't draw anything while we are using custom fonts that are in the process of loading.
+  // Don't draw anything while we are using custom fonts that are in the process
+  // of loading.
   if (shouldSkipDrawing())
     return false;
 
   if (runInfo.cachedTextBlob && runInfo.cachedTextBlob->get()) {
     // we have a pre-cached blob -- happy joy!
     canvas->drawTextBlob(runInfo.cachedTextBlob->get(), point.x(), point.y(),
                          paint);
     return true;
   }
 
   GlyphBuffer glyphBuffer;
   buildGlyphBuffer(runInfo, glyphBuffer);
 
   drawGlyphBuffer(canvas, paint, runInfo, glyphBuffer, point,
                   deviceScaleFactor);
   return true;
 }
 
 bool Font::drawBidiText(SkCanvas* canvas,
                         const TextRunPaintInfo& runInfo,
                         const FloatPoint& point,
                         CustomFontNotReadyAction customFontNotReadyAction,
                         float deviceScaleFactor,
                         const SkPaint& paint) const {
-  // Don't draw anything while we are using custom fonts that are in the process of loading,
-  // except if the 'force' argument is set to true (in which case it will use a fallback
-  // font).
+  // Don't draw anything while we are using custom fonts that are in the process
+  // of loading, except if the 'force' argument is set to true (in which case it
+  // will use a fallback font).
   if (shouldSkipDrawing() &&
       customFontNotReadyAction == DoNotPaintIfFontNotReady)
     return false;
 
   // sub-run painting is not supported for Bidi text.
   const TextRun& run = runInfo.run;
   ASSERT((runInfo.from == 0) && (runInfo.to == run.length()));
   BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
   bidiResolver.setStatus(
       BidiStatus(run.direction(), run.directionalOverride()));
@@ skipping 101 matching lines @@
     ASSERT(!done());
     const BlobRotation currentRotation = m_rotation;
 
     while (m_index < m_buffer.size()) {
       const SimpleFontData* fontData = m_buffer.fontDataAt(m_index);
       ASSERT(fontData);
 
       const BlobRotation newRotation = computeBlobRotation(fontData);
       if (newRotation != m_rotation) {
         // We're switching to an orientation which requires a different rotation
-        //   => emit the pending blob (and start a new one with the new rotation).
+        //   => emit the pending blob (and start a new one with the new
+        //      rotation).
         m_rotation = newRotation;
         break;
       }
 
       const unsigned start = m_index++;
       while (m_index < m_buffer.size() &&
              m_buffer.fontDataAt(m_index) == fontData)
         m_index++;
 
       appendRun(start, m_index - start, fontData);
     }
 
     m_blobCount++;
     return std::make_pair(m_builder.make(), currentRotation);
   }
 
  private:
   static BlobRotation computeBlobRotation(const SimpleFontData* font) {
-    // For vertical upright text we need to compensate the inherited 90deg CW rotation
-    // (using a 90deg CCW rotation).
+    // For vertical upright text we need to compensate the inherited 90deg CW
+    // rotation (using a 90deg CCW rotation).
     return (font->platformData().isVerticalAnyUpright() && font->verticalData())
                ? CCWRotation
                : NoRotation;
   }
 
   void appendRun(unsigned start,
                  unsigned count,
                  const SimpleFontData* fontData) {
     SkPaint paint;
     fontData->platformData().setupPaint(&paint, m_deviceScaleFactor, m_font);
@@ skipping 10 matching lines @@
     if (m_rotation == NoRotation) {
       std::copy(offsets, offsets + (m_hasVerticalOffsets ? 2 * count : count),
                 buffer.pos);
     } else {
       ASSERT(m_hasVerticalOffsets);
 
       const float verticalBaselineXOffset =
           fontData->getFontMetrics().floatAscent() -
           fontData->getFontMetrics().floatAscent(IdeographicBaseline);
 
-      // TODO(fmalita): why don't we apply this adjustment when building the glyph buffer?
+      // TODO(fmalita): why don't we apply this adjustment when building the
+      // glyph buffer?
       for (unsigned i = 0; i < 2 * count; i += 2) {
         buffer.pos[i] = SkFloatToScalar(offsets[i] + verticalBaselineXOffset);
         buffer.pos[i + 1] = SkFloatToScalar(offsets[i + 1]);
       }
     }
   }
 
   const GlyphBuffer& m_buffer;
   const Font* m_font;
   const float m_deviceScaleFactor;
@@ skipping 109 matching lines @@
   // FIXME: This really shouldn't be needed but for some reason the
   // TextRendering setting doesn't propagate to typesettingFeatures in time
   // for the prefs width calculation.
   if (getFontDescription().textRendering() == OptimizeLegibility ||
       getFontDescription().textRendering() == GeometricPrecision)
     return ComplexPath;
 
   if (run.is8Bit())
     return SimplePath;
 
-  // Start from 0 since drawing and highlighting also measure the characters before run->from.
+  // Start from 0 since drawing and highlighting also measure the characters
+  // before run->from.
   return Character::characterRangeCodePath(run.characters16(), run.length());
 }
 
 bool Font::canShapeWordByWord() const {
   if (!m_shapeWordByWordComputed) {
     m_canShapeWordByWord = computeCanShapeWordByWord();
     m_shapeWordByWordComputed = true;
   }
   return m_canShapeWordByWord;
 };
@@ skipping 24 matching lines @@
     GlyphData& data,
     unsigned pageNumber) {
   if (isUpright) {
     RefPtr<SimpleFontData> uprightFontData =
         data.fontData->uprightOrientationFontData();
     GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getNormalRootChild(
         uprightFontData.get(), pageNumber);
     GlyphPage* uprightPage = uprightNode->page();
     if (uprightPage) {
       GlyphData uprightData = uprightPage->glyphDataForCharacter(character);
-      // If the glyphs are the same, then we know we can just use the horizontal glyph rotated vertically to be upright.
+      // If the glyphs are the same, then we know we can just use the horizontal
+      // glyph rotated vertically to be upright.
       if (data.glyph == uprightData.glyph)
         return data;
-      // The glyphs are distinct, meaning that the font has a vertical-right glyph baked into it. We can't use that
-      // glyph, so we fall back to the upright data and use the horizontal glyph.
+      // The glyphs are distinct, meaning that the font has a vertical-right
+      // glyph baked into it. We can't use that glyph, so we fall back to the
+      // upright data and use the horizontal glyph.
       if (uprightData.fontData)
         return uprightData;
     }
   } else {
     RefPtr<SimpleFontData> verticalRightFontData =
         data.fontData->verticalRightOrientationFontData();
     GlyphPageTreeNode* verticalRightNode =
         GlyphPageTreeNode::getNormalRootChild(verticalRightFontData.get(),
                                               pageNumber);
     GlyphPage* verticalRightPage = verticalRightNode->page();
     if (verticalRightPage) {
       GlyphData verticalRightData =
           verticalRightPage->glyphDataForCharacter(character);
-      // If the glyphs are distinct, we will make the assumption that the font has a vertical-right glyph baked
-      // into it.
+      // If the glyphs are distinct, we will make the assumption that the font
+      // has a vertical-right glyph baked into it.
       if (data.glyph != verticalRightData.glyph)
         return data;
-      // The glyphs are identical, meaning that we should just use the horizontal glyph.
+      // The glyphs are identical, meaning that we should just use the
+      // horizontal glyph.
       if (verticalRightData.fontData)
         return verticalRightData;
     }
   }
   return data;
 }
 
 PassRefPtr<FontFallbackIterator> Font::createFontFallbackIterator(
     FontFallbackPriority fallbackPriority) const {
   return FontFallbackIterator::create(m_fontDescription, m_fontFallbackList,
@@ skipping 82 matching lines @@
           GlyphPageTreeNode* variantNode =
               GlyphPageTreeNode::getNormalRootChild(variantFontData.get(),
                                                     pageNumber);
           GlyphPage* variantPage = variantNode->page();
           if (variantPage) {
             GlyphData data = variantPage->glyphDataForCharacter(c);
             if (data.fontData)
               return data;
           }
 
-          // Do not attempt system fallback off the variantFontData. This is the very unlikely case that
-          // a font has the lowercase character but the small caps font does not have its uppercase version.
+          // Do not attempt system fallback off the variantFontData. This is the
+          // very unlikely case that a font has the lowercase character but the
+          // small caps font does not have its uppercase version.
           return variantFontData->missingGlyphData();
         }
 
         if (node->isSystemFallback())
           break;
       }
 
       // Proceed with the fallback list.
       node = toGlyphPageTreeNode(node)->getChild(fontDataAt(node->level()),
                                                  pageNumber);
@@ skipping 47 matching lines @@
           return glyphDataForNonCJKCharacterWithGlyphOrientation(
               characterToRender,
               m_fontDescription.isVerticalUpright(characterToRender), data,
               pageNumberForRendering);
       }
       return data;
     }
   }
 
   // Even system fallback can fail; use the missing glyph in that case.
-  // FIXME: It would be nicer to use the missing glyph from the last resort font instead.
+  // FIXME: It would be nicer to use the missing glyph from the last resort font
+  // instead.
   ASSERT(primaryFont());
   GlyphData data = primaryFont()->missingGlyphData();
   if (variant == NormalVariant) {
     page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
     data.fontData->setMaxGlyphPageTreeLevel(
         std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
   }
   return data;
 }
 
@@ skipping 73 matching lines @@
 }
 
 // Return the code point index for the given |x| offset into the text run.
 int Font::offsetForPositionForComplexText(const TextRun& run,
                                           float xFloat,
                                           bool includePartialGlyphs) const {
   CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
   return shaper.offsetForPosition(this, run, xFloat, includePartialGlyphs);
 }
 
-// Return the rectangle for selecting the given range of code-points in the TextRun.
+// Return the rectangle for selecting the given range of code-points in the
+// TextRun.
 FloatRect Font::selectionRectForComplexText(const TextRun& run,
                                             const FloatPoint& point,
                                             int height,
                                             int from,
                                             int to) const {
   CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
   CharacterRange range = shaper.getCharacterRange(this, run, from, to);
   return FloatRect(point.x() + range.start, point.y(), range.width(), height);
 }
 
@@ skipping 105 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink