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

third_party/WebKit/Source/modules/permissions/Permissions.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/permissions/Permissions.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 204 matching lines @@
     // Only append permissions types that are not already present in the vector.
     size_t internalIndex = kNotFound;
     for (size_t j = 0; j < internalPermissions.size(); ++j) {
       if (internalPermissions[j]->name == descriptor->name) {
         internalIndex = j;
         break;
       }
     }
     if (internalIndex == kNotFound) {
       internalIndex = internalPermissions.size();
-      internalPermissions.append(std::move(descriptor));
+      internalPermissions.push_back(std::move(descriptor));
     }
     callerIndexToInternalIndex[i] = internalIndex;
   }
 
   // This must be called after `parsePermission` because the website might
   // be able to run code.
   PermissionService* service = getService(scriptState->getExecutionContext());
   if (!service)
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "In its current state, the global "
                                           "scope can't request permissions."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   Vector<PermissionDescriptorPtr> internalPermissionsCopy;
   internalPermissionsCopy.reserveCapacity(internalPermissions.size());
   for (const auto& descriptor : internalPermissions)
-    internalPermissionsCopy.append(descriptor->Clone());
+    internalPermissionsCopy.push_back(descriptor->Clone());
 
   service->RequestPermissions(
       std::move(internalPermissions),
       scriptState->getExecutionContext()->getSecurityOrigin(),
       UserGestureIndicator::processingUserGestureThreadSafe(),
       convertToBaseCallback(
           WTF::bind(&Permissions::batchTaskComplete, wrapPersistent(this),
                     wrapPersistent(resolver),
                     WTF::passed(std::move(internalPermissionsCopy)),
                     WTF::passed(std::move(callerIndexToInternalIndex)))));
@@ skipping 37 matching lines @@
   if (!resolver->getExecutionContext() ||
       resolver->getExecutionContext()->isContextDestroyed())
     return;
 
   // Create the response vector by finding the status for each index by
   // using the caller to internal index mapping and looking up the status
   // using the internal index obtained.
   HeapVector<Member<PermissionStatus>> result;
   result.reserveInitialCapacity(callerIndexToInternalIndex.size());
   for (int internalIndex : callerIndexToInternalIndex) {
-    result.append(PermissionStatus::createAndListen(
+    result.push_back(PermissionStatus::createAndListen(
         resolver->getExecutionContext(), results[internalIndex],
         descriptors[internalIndex]->Clone()));
   }
   resolver->resolve(result);
 }
 
 }  // namespace blink