Pass the old and new owner documents to the adoptedCallback.

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 "bindings/core/v8/ScriptValue.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
@@ skipping 228 matching lines @@
             "attr2",
             HTMLNames::contenteditableAttr.localName(),
         })
     {
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         TestCustomElementDefinition::trace(visitor);
         visitor->trace(m_element);
+        visitor->trace(m_adopted);
     }
 
     // TODO(dominicc): Make this class collect a vector of what's
     // upgraded; it will be useful in more tests.
     Member<Element> m_element;
     enum MethodType {
         Constructor,
         ConnectedCallback,
         DisconnectedCallback,
         AdoptedCallback,
         AttributeChangedCallback,
     };
     Vector<MethodType> m_logs;
 
     struct AttributeChanged {
         QualifiedName name;
         AtomicString oldValue;
         AtomicString newValue;
     };
     Vector<AttributeChanged> m_attributeChanged;
 
+    struct Adopted : public GarbageCollected<Adopted> {
+        Adopted(Document* oldOwner, Document* newOwner)
+            : m_oldOwner(oldOwner)
+            , m_newOwner(newOwner) { }
+
+        Member<Document> m_oldOwner;
+        Member<Document> m_newOwner;
+
+        DEFINE_INLINE_TRACE()
+        {
+            visitor->trace(m_oldOwner);
+            visitor->trace(m_newOwner);
+        }
+    };
+    HeapVector<Member<Adopted>> m_adopted;
+
     void clear()
     {
         m_logs.clear();
         m_attributeChanged.clear();
     }
 
     bool runConstructor(Element* element) override
     {
         m_logs.append(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);
         EXPECT_EQ(element, m_element);
     }
 
     void runDisconnectedCallback(Element* element) override
     {
         m_logs.append(DisconnectedCallback);
         EXPECT_EQ(element, m_element);
     }
 
-    void runAdoptedCallback(Element* element) override
+    void runAdoptedCallback(
+        Element* element, Document* oldOwner, Document* newOwner) override
     {
         m_logs.append(AdoptedCallback);
         EXPECT_EQ(element, m_element);
+        m_adopted.append(new Adopted(oldOwner, newOwner));
     }
 
     void runAttributeChangedCallback(Element* element, const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue) override
     {
         m_logs.append(AttributeChangedCallback);
         EXPECT_EQ(element, m_element);
         m_attributeChanged.append(AttributeChanged { name, oldValue, newValue });
     }
 };
 
@@ skipping 154 matching lines @@
     {
         CEReactionsScope reactions;
         otherDocument->adoptNode(element, ASSERT_NO_EXCEPTION);
     }
     EXPECT_EQ(LogUpgradeDefinition::DisconnectedCallback, definition->m_logs[0])
         << "adoptNode() should invoke disconnectedCallback";
 
     EXPECT_EQ(LogUpgradeDefinition::AdoptedCallback, definition->m_logs[1])
         << "adoptNode() should invoke adoptedCallback";
 
+    EXPECT_EQ(&document(), definition->m_adopted[0]->m_oldOwner.get())
+        << "adoptedCallback should have been passed the old owner document";
+    EXPECT_EQ(otherDocument, definition->m_adopted[0]->m_newOwner.get())
+        << "adoptedCallback should have been passed the new owner document";
+
     EXPECT_EQ(2u, definition->m_logs.size())
         << "adoptNode() should not invoke other callbacks";
 }
 
 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.
 
 } // namespace blink