custom elements: Avoid dynamic allocation of HeapVector

Bug: 1154667
Change-Id: I8a838150309b3ebab3b41fe9d07cb6ab1fd7114c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2571282
Auto-Submit: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#833311}

third_party/blink/renderer/core/html/custom/custom_element_definition_test.cc

@@ -34,12 +34,11 @@ TEST(CustomElementDefinitionTest, upgrade_clearsReactionQueueOnFailure) {
       << "sanity check: this element should be ready to upgrade";
   {
     CEReactionsScope reactions;
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Unreached>(
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Unreached>(
         "upgrade failure should clear the reaction queue"));
     reactions.EnqueueToCurrentQueue(
-        element, *MakeGarbageCollected<TestReaction>(commands));
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
     ConstructorFails definition(CustomElementDescriptor("a-a", "a-a"));
     definition.Upgrade(element);
   }
@@ -53,12 +52,11 @@ TEST(CustomElementDefinitionTest,
   EXPECT_EQ(CustomElementState::kUndefined, element.GetCustomElementState())
       << "sanity check: this element should be ready to upgrade";
   ResetCustomElementReactionStackForTest reset_reaction_stack;
-  HeapVector<Member<Command>>* commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  commands->push_back(MakeGarbageCollected<Unreached>(
+  HeapVector<Member<Command>> commands;
+  commands.push_back(MakeGarbageCollected<Unreached>(
       "upgrade failure should clear the reaction queue"));
   reset_reaction_stack.Stack().EnqueueToBackupQueue(
-      element, *MakeGarbageCollected<TestReaction>(commands));
+      element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   ConstructorFails definition(CustomElementDescriptor("a-a", "a-a"));
   definition.Upgrade(element);
   EXPECT_EQ(CustomElementState::kFailed, element.GetCustomElementState())

third_party/blink/renderer/core/html/custom/custom_element_reaction_queue_test.cc

@@ -18,10 +18,9 @@ TEST(CustomElementReactionQueueTest, invokeReactions_one) {
   Vector<char> log;
   CustomElementReactionQueue* queue =
       MakeGarbageCollected<CustomElementReactionQueue>();
-  HeapVector<Member<Command>>* commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  commands->push_back(MakeGarbageCollected<Log>('a', log));
-  queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+  HeapVector<Member<Command>> commands;
+  commands.push_back(MakeGarbageCollected<Log>('a', log));
+  queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   Element* test_element = CreateElement(AtomicString("my-element"));
   queue->InvokeReactions(*test_element);
   EXPECT_EQ(log, Vector<char>({'a'}))
@@ -33,22 +32,19 @@ TEST(CustomElementReactionQueueTest, invokeReactions_many) {
   CustomElementReactionQueue* queue =
       MakeGarbageCollected<CustomElementReactionQueue>();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('c', log));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('c', log));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   Element* test_element = CreateElement(AtomicString("my-element"));
   queue->InvokeReactions(*test_element);
@@ -61,27 +57,24 @@ TEST(CustomElementReactionQueueTest, invokeReactions_recursive) {
   CustomElementReactionQueue* queue =
       MakeGarbageCollected<CustomElementReactionQueue>();
 
-  HeapVector<Member<Command>>* third_commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  third_commands->push_back(MakeGarbageCollected<Log>('c', log));
-  third_commands->push_back(MakeGarbageCollected<Recurse>(queue));
-  CustomElementReaction* third =
-      MakeGarbageCollected<TestReaction>(third_commands);  // "Empty" recursion
+  HeapVector<Member<Command>> third_commands;
+  third_commands.push_back(MakeGarbageCollected<Log>('c', log));
+  third_commands.push_back(MakeGarbageCollected<Recurse>(queue));
+  CustomElementReaction* third = MakeGarbageCollected<TestReaction>(
+      std::move(third_commands));  // "Empty" recursion
 
-  HeapVector<Member<Command>>* second_commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  second_commands->push_back(MakeGarbageCollected<Log>('b', log));
-  second_commands->push_back(MakeGarbageCollected<Enqueue>(queue, third));
+  HeapVector<Member<Command>> second_commands;
+  second_commands.push_back(MakeGarbageCollected<Log>('b', log));
+  second_commands.push_back(MakeGarbageCollected<Enqueue>(queue, third));
   CustomElementReaction* second = MakeGarbageCollected<TestReaction>(
-      second_commands);  // Unwinds one level of recursion
+      std::move(second_commands));  // Unwinds one level of recursion
 
-  HeapVector<Member<Command>>* first_commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  first_commands->push_back(MakeGarbageCollected<Log>('a', log));
-  first_commands->push_back(MakeGarbageCollected<Enqueue>(queue, second));
-  first_commands->push_back(MakeGarbageCollected<Recurse>(queue));
+  HeapVector<Member<Command>> first_commands;
+  first_commands.push_back(MakeGarbageCollected<Log>('a', log));
+  first_commands.push_back(MakeGarbageCollected<Enqueue>(queue, second));
+  first_commands.push_back(MakeGarbageCollected<Recurse>(queue));
   CustomElementReaction* first = MakeGarbageCollected<TestReaction>(
-      first_commands);  // Non-empty recursion
+      std::move(first_commands));  // Non-empty recursion
 
   queue->Add(*first);
   Element* test_element = CreateElement(AtomicString("my-element"));
@@ -96,24 +89,21 @@ TEST(CustomElementReactionQueueTest, clear_duringInvoke) {
       MakeGarbageCollected<CustomElementReactionQueue>();
 
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Call>(WTF::Bind(
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Call>(WTF::Bind(
         [](CustomElementReactionQueue* queue, Element&) { queue->Clear(); },
         WrapPersistent(queue))));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    queue->Add(*MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    queue->Add(*MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
 
   Element* test_element = CreateElement(AtomicString("my-element"));

third_party/blink/renderer/core/html/custom/custom_element_reaction_stack_test.cc

@@ -21,11 +21,11 @@ TEST(CustomElementReactionStackTest, one) {
   CustomElementReactionStack* stack =
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
-  HeapVector<Member<Command>>* commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  commands->push_back(MakeGarbageCollected<Log>('a', log));
-  stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                               *MakeGarbageCollected<TestReaction>(commands));
+  HeapVector<Member<Command>> commands;
+  commands.push_back(MakeGarbageCollected<Log>('a', log));
+  stack->EnqueueToCurrentQueue(
+      *CreateElement("a"),
+      *MakeGarbageCollected<TestReaction>(std::move(commands)));
   stack->PopInvokingReactions();
 
   EXPECT_EQ(log, Vector<char>({'a'}))
@@ -39,18 +39,18 @@ TEST(CustomElementReactionStackTest, multipleElements) {
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->PopInvokingReactions();
 
@@ -64,11 +64,11 @@ TEST(CustomElementReactionStackTest, popTopEmpty) {
   CustomElementReactionStack* stack =
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
-  HeapVector<Member<Command>>* commands =
-      MakeGarbageCollected<HeapVector<Member<Command>>>();
-  commands->push_back(MakeGarbageCollected<Log>('a', log));
-  stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                               *MakeGarbageCollected<TestReaction>(commands));
+  HeapVector<Member<Command>> commands;
+  commands.push_back(MakeGarbageCollected<Log>('a', log));
+  stack->EnqueueToCurrentQueue(
+      *CreateElement("a"),
+      *MakeGarbageCollected<TestReaction>(std::move(commands)));
   stack->Push();
   stack->PopInvokingReactions();
 
@@ -83,19 +83,19 @@ TEST(CustomElementReactionStackTest, popTop) {
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->PopInvokingReactions();
 
@@ -112,25 +112,23 @@ TEST(CustomElementReactionStackTest, requeueingDoesNotReorderElements) {
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    stack->EnqueueToCurrentQueue(element,
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    stack->EnqueueToCurrentQueue(
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('z', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('z', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    stack->EnqueueToCurrentQueue(element,
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    stack->EnqueueToCurrentQueue(
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->PopInvokingReactions();
 
@@ -147,33 +145,31 @@ TEST(CustomElementReactionStackTest, oneReactionQueuePerElement) {
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('a', log));
-    stack->EnqueueToCurrentQueue(element,
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('a', log));
+    stack->EnqueueToCurrentQueue(
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('z', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('z', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->Push();
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('y', log));
-    stack->EnqueueToCurrentQueue(*CreateElement("a"),
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('y', log));
+    stack->EnqueueToCurrentQueue(
+        *CreateElement("a"),
+        *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   {
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<Log>('b', log));
-    stack->EnqueueToCurrentQueue(element,
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<Log>('b', log));
+    stack->EnqueueToCurrentQueue(
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->PopInvokingReactions();
 
@@ -219,15 +215,14 @@ TEST(CustomElementReactionStackTest, enqueueFromReaction) {
       MakeGarbageCollected<CustomElementReactionStack>();
   stack->Push();
   {
-    HeapVector<Member<Command>>* subcommands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    subcommands->push_back(MakeGarbageCollected<Log>('a', log));
-    HeapVector<Member<Command>>* commands =
-        MakeGarbageCollected<HeapVector<Member<Command>>>();
-    commands->push_back(MakeGarbageCollected<EnqueueToStack>(
-        stack, element, MakeGarbageCollected<TestReaction>(subcommands)));
-    stack->EnqueueToCurrentQueue(element,
-                                 *MakeGarbageCollected<TestReaction>(commands));
+    HeapVector<Member<Command>> subcommands;
+    subcommands.push_back(MakeGarbageCollected<Log>('a', log));
+    HeapVector<Member<Command>> commands;
+    commands.push_back(MakeGarbageCollected<EnqueueToStack>(
+        stack, element,
+        MakeGarbageCollected<TestReaction>(std::move(subcommands))));
+    stack->EnqueueToCurrentQueue(
+        element, *MakeGarbageCollected<TestReaction>(std::move(commands)));
   }
   stack->PopInvokingReactions();
 

third_party/blink/renderer/core/html/custom/custom_element_reaction_test_helpers.h

@@ -107,23 +107,23 @@ class Enqueue : public Command {
 
 class TestReaction : public CustomElementReaction {
  public:
-  TestReaction(HeapVector<Member<Command>>* commands)
+  explicit TestReaction(HeapVector<Member<Command>>&& commands)
       : CustomElementReaction(
             *MakeGarbageCollected<TestCustomElementDefinition>(
                 CustomElementDescriptor("mock-element", "mock-element"))),
-        commands_(commands) {}
+        commands_(std::move(commands)) {}
   ~TestReaction() override = default;
   void Trace(Visitor* visitor) const override {
     CustomElementReaction::Trace(visitor);
     visitor->Trace(commands_);
   }
   void Invoke(Element& element) override {
-    for (auto& command : *commands_)
+    for (auto& command : commands_)
       command->Run(element);
   }
 
  private:
-  Member<HeapVector<Member<Command>>> commands_;
+  HeapVector<Member<Command>> commands_;
 
   DISALLOW_COPY_AND_ASSIGN(TestReaction);
 };