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

third_party/WebKit/Source/web/tests/ActivityLoggerTest.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 "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "public/web/WebCache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/Forward.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Base64.h"
 #include <v8.h>
 
 namespace blink {
 
 using blink::FrameTestHelpers::WebViewHelper;
 using blink::FrameTestHelpers::pumpPendingRequestsForFrameToLoad;
 
 class TestActivityLogger : public V8DOMActivityLogger {
  public:
   ~TestActivityLogger() override {}
 
   void logGetter(const String& apiName) override {
-    m_loggedActivities.append(apiName);
+    m_loggedActivities.push_back(apiName);
   }
 
   void logSetter(const String& apiName,
                  const v8::Local<v8::Value>& newValue) override {
-    m_loggedActivities.append(apiName + " | " +
-                              toCoreStringWithUndefinedOrNullCheck(newValue));
+    m_loggedActivities.push_back(
+        apiName + " | " + toCoreStringWithUndefinedOrNullCheck(newValue));
   }
 
   void logMethod(const String& apiName,
                  int argc,
                  const v8::Local<v8::Value>* argv) override {
     String activityString = apiName;
     for (int i = 0; i < argc; i++)
       activityString = activityString + " | " +
                        toCoreStringWithUndefinedOrNullCheck(argv[i]);
-    m_loggedActivities.append(activityString);
+    m_loggedActivities.push_back(activityString);
   }
 
   void logEvent(const String& eventName,
                 int argc,
                 const String* argv) override {
     String activityString = eventName;
     for (int i = 0; i < argc; i++) {
       activityString = activityString + " | " + argv[i];
     }
-    m_loggedActivities.append(activityString);
+    m_loggedActivities.push_back(activityString);
   }
 
   void clear() { m_loggedActivities.clear(); }
   bool verifyActivities(const Vector<String>& expected) const {
     EXPECT_EQ(expected.size(), m_loggedActivities.size());
     for (size_t i = 0; i < std::min(expected.size(), m_loggedActivities.size());
          ++i) {
       EXPECT_STREQ(expected[i].utf8().data(),
                    m_loggedActivities[i].utf8().data());
     }
@@ skipping 21 matching lines @@
 
   void executeScriptInMainWorld(const String& script) const {
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     m_scriptController->executeScriptInMainWorld(script);
     pumpPendingRequestsForFrameToLoad(m_webViewHelper.webView()->mainFrame());
   }
 
   void executeScriptInIsolatedWorld(const String& script) const {
     v8::HandleScope scope(v8::Isolate::GetCurrent());
     HeapVector<ScriptSourceCode> sources;
-    sources.append(ScriptSourceCode(script));
+    sources.push_back(ScriptSourceCode(script));
     Vector<v8::Local<v8::Value>> results;
     m_scriptController->executeScriptInIsolatedWorld(isolatedWorldId, sources,
                                                      extensionGroup, 0);
     pumpPendingRequestsForFrameToLoad(m_webViewHelper.webView()->mainFrame());
   }
 
   bool verifyActivities(const String& activities) {
     Vector<String> activityVector;
     activities.split("\n", activityVector);
     return m_activityLogger->verifyActivities(activityVector);
@@ skipping 479 matching lines @@
       "blinkRequestResource | Script | data:text/html;charset=utf-8,D\n"
       "blinkRequestResource | XMLHttpRequest | data:text/html;charset=utf-8,E\n"
       "blinkRequestResource | Image | data:text/html;charset=utf-8,B\n";
   executeScriptInMainWorld(code);
   ASSERT_TRUE(verifyActivities(""));
   executeScriptInIsolatedWorld(code);
   ASSERT_TRUE(verifyActivities(expectedActivities));
 }
 
 }  // namespace blink