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

third_party/WebKit/Source/platform/network/HTTPParsers.cpp

 /*
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2011 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:
@@ skipping 143 matching lines @@
 
 // suborigin-name = LOWERALPHA *( LOWERALPHA / DIGIT )
 //
 // Does not trim whitespace before or after the suborigin-name.
 const UChar* parseSuboriginName(const UChar* begin,
                                 const UChar* end,
                                 String& name,
                                 WTF::Vector<String>& messages) {
   // Parse the name of the suborigin (no spaces, single string)
   if (begin == end) {
-    messages.append(String("No Suborigin name specified."));
+    messages.push_back(String("No Suborigin name specified."));
     return nullptr;
   }
 
   const UChar* position = begin;
 
   if (!skipExactly<UChar, isASCIILower>(position, end)) {
-    messages.append("Invalid character \'" + String(position, 1) +
-                    "\' in suborigin. First character must be a lower case "
-                    "alphabetic character.");
+    messages.push_back("Invalid character \'" + String(position, 1) +
+                       "\' in suborigin. First character must be a lower case "
+                       "alphabetic character.");
     return nullptr;
   }
 
   skipWhile<UChar, isASCIILowerAlphaOrDigit>(position, end);
   if (position != end && !isASCIISpace(*position)) {
-    messages.append("Invalid character \'" + String(position, 1) +
-                    "\' in suborigin.");
+    messages.push_back("Invalid character \'" + String(position, 1) +
+                       "\' in suborigin.");
     return nullptr;
   }
 
   size_t length = position - begin;
   name = String(begin, length).lower();
   return position;
 }
 
 const UChar* parseSuboriginPolicyOption(const UChar* begin,
                                         const UChar* end,
                                         String& option,
                                         WTF::Vector<String>& messages) {
   const UChar* position = begin;
 
   if (*position != '\'') {
-    messages.append("Invalid character \'" + String(position, 1) +
-                    "\' in suborigin policy. Suborigin policy options must "
-                    "start and end with a single quote.");
+    messages.push_back("Invalid character \'" + String(position, 1) +
+                       "\' in suborigin policy. Suborigin policy options must "
+                       "start and end with a single quote.");
     return nullptr;
   }
   position = position + 1;
 
   skipWhile<UChar, isASCIILowerAlphaOrDigitOrHyphen>(position, end);
   if (position == end || isASCIISpace(*position)) {
-    messages.append(String("Expected \' to end policy option."));
+    messages.push_back(String("Expected \' to end policy option."));
     return nullptr;
   }
 
   if (*position != '\'') {
-    messages.append("Invalid character \'" + String(position, 1) +
-                    "\' in suborigin policy.");
+    messages.push_back("Invalid character \'" + String(position, 1) +
+                       "\' in suborigin policy.");
     return nullptr;
   }
 
   ASSERT(position > begin);
   size_t length = (position + 1) - begin;
 
   option = String(begin, length);
   return position + 1;
 }
 
@@ skipping 409 matching lines @@
           safeHeader.substring(pos, nextEqualSignPosition - pos)
               .stripWhiteSpace());
       pos += nextEqualSignPosition - pos + 1;
 
       String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
       if (value[0] == '"') {
         // The value is a quoted string
         size_t nextDoubleQuotePosition = value.find('"', 1);
         if (nextDoubleQuotePosition != kNotFound) {
           // Store the value as a quoted string without quotes
-          result.append(std::pair<String, String>(
+          result.push_back(std::pair<String, String>(
               directive, value.substring(1, nextDoubleQuotePosition - 1)
                              .stripWhiteSpace()));
           pos +=
               (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
           // Move past next comma, if there is one
           size_t nextCommaPosition2 = safeHeader.find(',', pos);
           if (nextCommaPosition2 != kNotFound)
             pos += nextCommaPosition2 - pos + 1;
           else
             return;  // Parse error if there is anything left with no comma
         } else {
           // Parse error; just use the rest as the value
-          result.append(std::pair<String, String>(
+          result.push_back(std::pair<String, String>(
               directive,
               trimToNextSeparator(
                   value.substring(1, value.length() - 1).stripWhiteSpace())));
           return;
         }
       } else {
         // The value is a token until the next comma
         size_t nextCommaPosition2 = value.find(',');
         if (nextCommaPosition2 != kNotFound) {
           // The value is delimited by the next comma
-          result.append(std::pair<String, String>(
+          result.push_back(std::pair<String, String>(
               directive,
               trimToNextSeparator(
                   value.substring(0, nextCommaPosition2).stripWhiteSpace())));
           pos += (safeHeader.find(',', pos) - pos) + 1;
         } else {
           // The rest is the value; no change to value needed
-          result.append(
+          result.push_back(
               std::pair<String, String>(directive, trimToNextSeparator(value)));
           return;
         }
       }
     } else if (nextCommaPosition != kNotFound &&
                (nextCommaPosition < nextEqualSignPosition ||
                 nextEqualSignPosition == kNotFound)) {
       // Add directive to map with empty string as value
-      result.append(std::pair<String, String>(
+      result.push_back(std::pair<String, String>(
           trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos)
                                   .stripWhiteSpace()),
           ""));
       pos += nextCommaPosition - pos + 1;
     } else {
       // Add last directive to map with empty string as value
-      result.append(std::pair<String, String>(
+      result.push_back(std::pair<String, String>(
           trimToNextSeparator(
               safeHeader.substring(pos, max - pos).stripWhiteSpace()),
           ""));
       return;
     }
   }
 }
 
 CacheControlHeader parseCacheControlDirectives(
     const AtomicString& cacheControlValue,
@@ skipping 70 matching lines @@
     headerSet.add(value.stripWhiteSpace(isWhitespace));
 }
 
 bool parseSuboriginHeader(const String& header,
                           Suborigin* suborigin,
                           WTF::Vector<String>& messages) {
   Vector<String> headers;
   header.split(',', true, headers);
 
   if (headers.size() > 1)
-    messages.append(
+    messages.push_back(
         "Multiple Suborigin headers found. Ignoring all but the first.");
 
   Vector<UChar> characters;
   headers[0].appendTo(characters);
 
   const UChar* position = characters.data();
   const UChar* end = position + characters.size();
 
   skipWhile<UChar, isASCIISpace>(position, end);
 
@@ skipping 16 matching lines @@
     position = parseSuboriginPolicyOption(position, end, optionName, messages);
 
     if (!position) {
       suborigin->clear();
       return false;
     }
 
     Suborigin::SuboriginPolicyOptions option =
         getSuboriginPolicyOptionFromString(optionName);
     if (option == Suborigin::SuboriginPolicyOptions::None)
-      messages.append("Ignoring unknown suborigin policy option " + optionName +
-                      ".");
+      messages.push_back("Ignoring unknown suborigin policy option " +
+                         optionName + ".");
     else
       suborigin->addPolicyOption(option);
   }
 
   return true;
 }
 
 bool parseMultipartHeadersFromBody(const char* bytes,
                                    size_t size,
                                    ResourceResponse* response,
@@ skipping 44 matching lines @@
   StringBuilder sb;
   sb.append("[");
   sb.append(header);
   sb.append("]");
   std::unique_ptr<JSONValue> headerValue =
       parseJSON(sb.toString(), maxParseDepth);
   return JSONArray::from(std::move(headerValue));
 }
 
 }  // namespace blink