Migrate WTF::Vector::append() to ::push_back() [part 14 of N]

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 290 matching lines @@
   for (auto it = holesQueue.begin(); it != holesQueue.end(); ++it) {
     if (it->m_action == HolesQueueNextFont)
       break;
 
     UChar32 hintChar;
     RELEASE_ASSERT(it->m_startIndex + it->m_numCharacters <=
                    m_normalizedBufferLength);
     UTF16TextIterator iterator(m_normalizedBuffer + it->m_startIndex,
                                it->m_numCharacters);
     while (iterator.consume(hintChar)) {
-      hint.append(hintChar);
+      hint.push_back(hintChar);
       numCharsAdded++;
       iterator.advance();
     }
   }
   return numCharsAdded > 0;
 }
 
 namespace {
 using HolesQueueItem = HarfBuzzShaper::HolesQueueItem;
 using HolesQueueItemAction = HarfBuzzShaper::HolesQueueItemAction;
@@ skipping 25 matching lines @@
 void setFontFeatures(const Font* font, FeaturesVector* features) {
   const FontDescription& description = font->getFontDescription();
 
   static hb_feature_t noKern = createFeature(HB_TAG('k', 'e', 'r', 'n'));
   static hb_feature_t noVkrn = createFeature(HB_TAG('v', 'k', 'r', 'n'));
   switch (description.getKerning()) {
     case FontDescription::NormalKerning:
       // kern/vkrn are enabled by default
       break;
     case FontDescription::NoneKerning:
-      features->append(description.isVerticalAnyUpright() ? noVkrn : noKern);
+      features->push_back(description.isVerticalAnyUpright() ? noVkrn : noKern);
       break;
     case FontDescription::AutoKerning:
       break;
   }
 
   static hb_feature_t noClig = createFeature(HB_TAG('c', 'l', 'i', 'g'));
   static hb_feature_t noLiga = createFeature(HB_TAG('l', 'i', 'g', 'a'));
   switch (description.commonLigaturesState()) {
     case FontDescription::DisabledLigaturesState:
-      features->append(noLiga);
-      features->append(noClig);
+      features->push_back(noLiga);
+      features->push_back(noClig);
       break;
     case FontDescription::EnabledLigaturesState:
       // liga and clig are on by default
       break;
     case FontDescription::NormalLigaturesState:
       break;
   }
   static hb_feature_t dlig = createFeature(HB_TAG('d', 'l', 'i', 'g'), 1);
   switch (description.discretionaryLigaturesState()) {
     case FontDescription::DisabledLigaturesState:
       // dlig is off by default
       break;
     case FontDescription::EnabledLigaturesState:
-      features->append(dlig);
+      features->push_back(dlig);
       break;
     case FontDescription::NormalLigaturesState:
       break;
   }
   static hb_feature_t hlig = createFeature(HB_TAG('h', 'l', 'i', 'g'), 1);
   switch (description.historicalLigaturesState()) {
     case FontDescription::DisabledLigaturesState:
       // hlig is off by default
       break;
     case FontDescription::EnabledLigaturesState:
-      features->append(hlig);
+      features->push_back(hlig);
       break;
     case FontDescription::NormalLigaturesState:
       break;
   }
   static hb_feature_t noCalt = createFeature(HB_TAG('c', 'a', 'l', 't'));
   switch (description.contextualLigaturesState()) {
     case FontDescription::DisabledLigaturesState:
-      features->append(noCalt);
+      features->push_back(noCalt);
       break;
     case FontDescription::EnabledLigaturesState:
       // calt is on by default
       break;
     case FontDescription::NormalLigaturesState:
       break;
   }
 
   static hb_feature_t hwid = createFeature(HB_TAG('h', 'w', 'i', 'd'), 1);
   static hb_feature_t twid = createFeature(HB_TAG('t', 'w', 'i', 'd'), 1);
   static hb_feature_t qwid = createFeature(HB_TAG('q', 'w', 'i', 'd'), 1);
   switch (description.widthVariant()) {
     case HalfWidth:
-      features->append(hwid);
+      features->push_back(hwid);
       break;
     case ThirdWidth:
-      features->append(twid);
+      features->push_back(twid);
       break;
     case QuarterWidth:
-      features->append(qwid);
+      features->push_back(qwid);
       break;
     case RegularWidth:
       break;
   }
 
   // font-variant-numeric:
   static hb_feature_t lnum = createFeature(HB_TAG('l', 'n', 'u', 'm'), 1);
   if (description.variantNumeric().numericFigureValue() ==
       FontVariantNumeric::LiningNums)
-    features->append(lnum);
+    features->push_back(lnum);
 
   static hb_feature_t onum = createFeature(HB_TAG('o', 'n', 'u', 'm'), 1);
   if (description.variantNumeric().numericFigureValue() ==
       FontVariantNumeric::OldstyleNums)
-    features->append(onum);
+    features->push_back(onum);
 
   static hb_feature_t pnum = createFeature(HB_TAG('p', 'n', 'u', 'm'), 1);
   if (description.variantNumeric().numericSpacingValue() ==
       FontVariantNumeric::ProportionalNums)
-    features->append(pnum);
+    features->push_back(pnum);
   static hb_feature_t tnum = createFeature(HB_TAG('t', 'n', 'u', 'm'), 1);
   if (description.variantNumeric().numericSpacingValue() ==
       FontVariantNumeric::TabularNums)
-    features->append(tnum);
+    features->push_back(tnum);
 
   static hb_feature_t afrc = createFeature(HB_TAG('a', 'f', 'r', 'c'), 1);
   if (description.variantNumeric().numericFractionValue() ==
       FontVariantNumeric::StackedFractions)
-    features->append(afrc);
+    features->push_back(afrc);
   static hb_feature_t frac = createFeature(HB_TAG('f', 'r', 'a', 'c'), 1);
   if (description.variantNumeric().numericFractionValue() ==
       FontVariantNumeric::DiagonalFractions)
-    features->append(frac);
+    features->push_back(frac);
 
   static hb_feature_t ordn = createFeature(HB_TAG('o', 'r', 'd', 'n'), 1);
   if (description.variantNumeric().ordinalValue() ==
       FontVariantNumeric::OrdinalOn)
-    features->append(ordn);
+    features->push_back(ordn);
 
   static hb_feature_t zero = createFeature(HB_TAG('z', 'e', 'r', 'o'), 1);
   if (description.variantNumeric().slashedZeroValue() ==
       FontVariantNumeric::SlashedZeroOn)
-    features->append(zero);
+    features->push_back(zero);
 
   FontFeatureSettings* settings = description.featureSettings();
   if (!settings)
     return;
 
   // TODO(drott): crbug.com/450619 Implement feature resolution instead of
   // just appending the font-feature-settings.
   unsigned numFeatures = settings->size();
   for (unsigned i = 0; i < numFeatures; ++i) {
     hb_feature_t feature;
     const AtomicString& tag = settings->at(i).tag();
     feature.tag = HB_TAG(tag[0], tag[1], tag[2], tag[3]);
     feature.value = settings->at(i).value();
     feature.start = 0;
     feature.end = static_cast<unsigned>(-1);
-    features->append(feature);
+    features->push_back(feature);
   }
 }
 
 class CapsFeatureSettingsScopedOverlay final {
   STACK_ALLOCATED()
 
  public:
   CapsFeatureSettingsScopedOverlay(FeaturesVector*,
                                    FontDescription::FontVariantCaps);
   CapsFeatureSettingsScopedOverlay() = delete;
@@ skipping 177 matching lines @@
               segmentRange.script, !fallbackIterator->hasNext()))
         DLOG(ERROR) << "Shape result extraction failed.";
 
       hb_buffer_reset(harfBuzzBuffer.get());
     }
   }
   return result.release();
 }
 
 }  // namespace blink