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

third_party/WebKit/Source/core/dom/custom/CustomElementRegistryTest.cpp

 // Copyright 2016 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 "core/dom/custom/CustomElementRegistry.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementDefinitionOptions.h"
@@ skipping 201 matching lines @@
     }
   };
   HeapVector<Member<Adopted>> m_adopted;
 
   void clear() {
     m_logs.clear();
     m_attributeChanged.clear();
   }
 
   bool runConstructor(Element* element) override {
-    m_logs.append(Constructor);
+    m_logs.push_back(Constructor);
     m_element = element;
     return TestCustomElementDefinition::runConstructor(element);
   }
 
   bool hasConnectedCallback() const override { return true; }
   bool hasDisconnectedCallback() const override { return true; }
   bool hasAdoptedCallback() const override { return true; }
 
   void runConnectedCallback(Element* element) override {
-    m_logs.append(ConnectedCallback);
+    m_logs.push_back(ConnectedCallback);
     EXPECT_EQ(element, m_element);
   }
 
   void runDisconnectedCallback(Element* element) override {
-    m_logs.append(DisconnectedCallback);
+    m_logs.push_back(DisconnectedCallback);
     EXPECT_EQ(element, m_element);
   }
 
   void runAdoptedCallback(Element* element,
                           Document* oldOwner,
                           Document* newOwner) override {
-    m_logs.append(AdoptedCallback);
+    m_logs.push_back(AdoptedCallback);
     EXPECT_EQ(element, m_element);
-    m_adopted.append(new Adopted(oldOwner, newOwner));
+    m_adopted.push_back(new Adopted(oldOwner, newOwner));
   }
 
   void runAttributeChangedCallback(Element* element,
                                    const QualifiedName& name,
                                    const AtomicString& oldValue,
                                    const AtomicString& newValue) override {
-    m_logs.append(AttributeChangedCallback);
+    m_logs.push_back(AttributeChangedCallback);
     EXPECT_EQ(element, m_element);
-    m_attributeChanged.append(AttributeChanged{name, oldValue, newValue});
+    m_attributeChanged.push_back(AttributeChanged{name, oldValue, newValue});
   }
 };
 
 class LogUpgradeBuilder final : public TestCustomElementDefinitionBuilder {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(LogUpgradeBuilder);
 
  public:
   LogUpgradeBuilder() {}
 
@@ skipping 172 matching lines @@
   EXPECT_EQ(definitionB, definition);
   // look up undefined customized built-in element
   definition = registry().definitionFor(CustomElementDescriptor("a-a", "div"));
   EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
 }
 
 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.
 
 }  // namespace blink