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

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 759 matching lines @@
       "<style>"
       // This stylesheet checks that the internal property and value can't be
       // set by a stylesheet, only WebDocument::watchCSSSelectors().
       "div.initial_on { -internal-callback: none; }"
       "div.initial_off { -internal-callback: -internal-presence; }"
       "</style>"
       "<div class=\"initial_on\"></div>"
       "<div class=\"initial_off\"></div>");
 
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("div.initial_on"));
+  selectors.push_back(WebString::fromUTF8("div.initial_on"));
   m_frame->document().watchCSSSelectors(WebVector<WebString>(selectors));
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("div.initial_on"));
 
   // Check that adding a watched selector calls back for already-present nodes.
-  selectors.append(WebString::fromUTF8("div.initial_off"));
+  selectors.push_back(WebString::fromUTF8("div.initial_off"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
   EXPECT_EQ(2, updateCount());
   EXPECT_THAT(matchedSelectors(),
               ElementsAre("div.initial_off", "div.initial_on"));
 
   // Check that we can turn off callbacks for certain selectors.
   doc().watchCSSSelectors(WebVector<WebString>());
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
   EXPECT_EQ(3, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, SharedComputedStyle) {
   // Check that adding an element calls back when it matches an existing rule.
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span"));
+  selectors.push_back(WebString::fromUTF8("span"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
 
   executeScript(
       "i1 = document.createElement('span');"
       "i1.id = 'first_span';"
       "document.body.appendChild(i1)");
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
   // Adding a second element that shares a ComputedStyle shouldn't call back.
@@ skipping 19 matching lines @@
       "i2 = document.getElementById('second_span');"
       "i2.parentNode.removeChild(i2);");
   EXPECT_EQ(2, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, CatchesAttributeChange) {
   loadHTML("<span></span>");
 
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span[attr=\"value\"]"));
+  selectors.push_back(WebString::fromUTF8("span[attr=\"value\"]"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   runPendingTasks();
 
   EXPECT_EQ(0, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre());
 
   executeScript(
       "document.querySelector('span').setAttribute('attr', 'value');");
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("span[attr=\"value\"]"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, DisplayNone) {
   loadHTML("<div style='display:none'><span></span></div>");
 
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span"));
+  selectors.push_back(WebString::fromUTF8("span"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   runPendingTasks();
 
   EXPECT_EQ(0, updateCount()) << "Don't match elements in display:none trees.";
 
   executeScript(
       "d = document.querySelector('div');"
       "d.style.display = 'block';");
   EXPECT_EQ(1, updateCount()) << "Match elements when they become displayed.";
   EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
@@ skipping 31 matching lines @@
       << "Undisplaying the span directly should produce another callback.";
   EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, Reparenting) {
   loadHTML(
       "<div id='d1'><span></span></div>"
       "<div id='d2'></div>");
 
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span"));
+  selectors.push_back(WebString::fromUTF8("span"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
 
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
   executeScript(
       "s = document.querySelector('span');"
       "d2 = document.getElementById('d2');"
       "d2.appendChild(s);");
   EXPECT_EQ(1, updateCount()) << "Just moving an element that continues to "
                                  "match shouldn't send a spurious callback.";
   EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, MultiSelector) {
   loadHTML("<span></span>");
 
   // Check that selector lists match as the whole list, not as each element
   // independently.
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span"));
-  selectors.append(WebString::fromUTF8("span,p"));
+  selectors.push_back(WebString::fromUTF8("span"));
+  selectors.push_back(WebString::fromUTF8("span,p"));
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
 
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("span", "span, p"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, InvalidSelector) {
   loadHTML("<p><span></span></p>");
 
   // Build a list with one valid selector and one invalid.
   Vector<WebString> selectors;
-  selectors.append(WebString::fromUTF8("span"));
-  selectors.append(WebString::fromUTF8("["));       // Invalid.
-  selectors.append(WebString::fromUTF8("p span"));  // Not compound.
+  selectors.push_back(WebString::fromUTF8("span"));
+  selectors.push_back(WebString::fromUTF8("["));       // Invalid.
+  selectors.push_back(WebString::fromUTF8("p span"));  // Not compound.
   doc().watchCSSSelectors(WebVector<WebString>(selectors));
   m_frame->view()->updateAllLifecyclePhases();
   runPendingTasks();
 
   EXPECT_EQ(1, updateCount());
   EXPECT_THAT(matchedSelectors(), ElementsAre("span"))
       << "An invalid selector shouldn't prevent other selectors from matching.";
 }
 
 TEST_P(ParameterizedWebFrameTest, DispatchMessageEventWithOriginCheck) {
@@ skipping 3305 matching lines @@
   }
 
   Vector<std::unique_ptr<Notification>> createNotifications;
   Vector<std::unique_ptr<Notification>> releaseNotifications;
 
  private:
   void didCreateScriptContext(WebLocalFrame* frame,
                               v8::Local<v8::Context> context,
                               int extensionGroup,
                               int worldId) override {
-    createNotifications.append(
+    createNotifications.push_back(
         WTF::makeUnique<Notification>(frame, context, worldId));
   }
 
   void willReleaseScriptContext(WebLocalFrame* frame,
                                 v8::Local<v8::Context> context,
                                 int worldId) override {
-    releaseNotifications.append(
+    releaseNotifications.push_back(
         WTF::makeUnique<Notification>(frame, context, worldId));
   }
 };
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsLoadUnload) {
   v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
   registerMockedHttpURLLoad("context_notifications_test.html");
   registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
@@ skipping 630 matching lines @@
 
   // Get the tickmarks for the original find request.
   FrameView* frameView = webViewHelper.webView()->mainFrameImpl()->frameView();
   Scrollbar* scrollbar = frameView->createScrollbar(HorizontalScrollbar);
   Vector<IntRect> originalTickmarks;
   scrollbar->getTickmarks(originalTickmarks);
   EXPECT_EQ(4u, originalTickmarks.size());
 
   // Override the tickmarks.
   Vector<IntRect> overridingTickmarksExpected;
-  overridingTickmarksExpected.append(IntRect(0, 0, 100, 100));
-  overridingTickmarksExpected.append(IntRect(0, 20, 100, 100));
-  overridingTickmarksExpected.append(IntRect(0, 30, 100, 100));
+  overridingTickmarksExpected.push_back(IntRect(0, 0, 100, 100));
+  overridingTickmarksExpected.push_back(IntRect(0, 20, 100, 100));
+  overridingTickmarksExpected.push_back(IntRect(0, 30, 100, 100));
   mainFrame->setTickmarks(overridingTickmarksExpected);
 
   // Check the tickmarks are overriden correctly.
   Vector<IntRect> overridingTickmarksActual;
   scrollbar->getTickmarks(overridingTickmarksActual);
   EXPECT_EQ(overridingTickmarksExpected, overridingTickmarksActual);
 
   // Reset the tickmark behavior.
   Vector<IntRect> resetTickmarks;
   mainFrame->setTickmarks(resetTickmarks);
@@ skipping 1320 matching lines @@
       : m_numberOfTimesChecked(0), m_hash(hash) {}
   virtual ~SpellCheckClient() {}
   void requestCheckingOfText(const WebString&,
                              const WebVector<uint32_t>&,
                              const WebVector<unsigned>&,
                              WebTextCheckingCompletion* completion) override {
     ++m_numberOfTimesChecked;
     Vector<WebTextCheckingResult> results;
     const int misspellingStartOffset = 1;
     const int misspellingLength = 8;
-    results.append(WebTextCheckingResult(
+    results.push_back(WebTextCheckingResult(
         WebTextDecorationTypeSpelling, misspellingStartOffset,
         misspellingLength, WebString(), m_hash));
     completion->didFinishCheckingText(results);
   }
   int numberOfTimesChecked() const { return m_numberOfTimesChecked; }
 
  private:
   int m_numberOfTimesChecked;
   uint32_t m_hash;
 };
@@ skipping 84 matching lines @@
   element->focus();
   NonThrowableExceptionState exceptionState;
   document->execCommand("InsertText", false, " wellcome ", exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   WebVector<uint32_t> documentMarkers1;
   webViewHelper.webView()->spellingMarkers(&documentMarkers1);
   EXPECT_EQ(1U, documentMarkers1.size());
 
   Vector<String> words;
-  words.append("wellcome");
+  words.push_back("wellcome");
   frame->removeSpellingMarkersUnderWords(words);
 
   WebVector<uint32_t> documentMarkers2;
   webViewHelper.webView()->spellingMarkers(&documentMarkers2);
   EXPECT_EQ(0U, documentMarkers2.size());
 }
 
 TEST_P(ParameterizedWebFrameTest, MarkerHashIdentifiers) {
   registerMockedHttpURLLoad("spell.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 52 matching lines @@
   }
 
  private:
   void kick(int misspellingStartOffset,
             int misspellingLength,
             WebTextDecorationType type) {
     if (!m_completion)
       return;
     Vector<WebTextCheckingResult> results;
     if (misspellingStartOffset >= 0 && misspellingLength > 0)
-      results.append(WebTextCheckingResult(type, misspellingStartOffset,
-                                           misspellingLength));
+      results.push_back(WebTextCheckingResult(type, misspellingStartOffset,
+                                              misspellingLength));
     m_completion->didFinishCheckingText(results);
     m_completion = 0;
   }
 
   WebTextCheckingCompletion* m_completion;
 };
 
 TEST_P(ParameterizedWebFrameTest, SlowSpellcheckMarkerPosition) {
   registerMockedHttpURLLoad("spell.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 2922 matching lines @@
   childFrame->close();
 }
 
 class TestConsoleMessageWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   virtual void didAddMessageToConsole(const WebConsoleMessage& message,
                                       const WebString& sourceName,
                                       unsigned sourceLine,
                                       const WebString& stackTrace) {
-    messages.append(message);
+    messages.push_back(message);
   }
 
   Vector<WebConsoleMessage> messages;
 };
 
 TEST_P(ParameterizedWebFrameTest, CrossDomainAccessErrorsUseCallingWindow) {
   registerMockedHttpURLLoad("hidden_frames.html");
   registerMockedChromeURLLoad("hello_world.html");
 
   FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 1748 matching lines @@
 
   EXPECT_TRUE(mainFrameClient.childClient().didCallFrameDetached());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidStopLoading());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidFinishDocumentLoad());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidHandleOnloadEvents());
 
   webViewHelper.reset();
 }
 
 }  // namespace blink