ExternalPopupMenu should recreate its popup only if a SELECT subtree is updated

third_party/WebKit/Source/core/html/HTMLSelectElement.cpp

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
@@ skipping 18 matching lines @@
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/UnionTypesCore.h"
 #include "core/HTMLNames.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExecutionContextTask.h"
+#include "core/dom/MutationCallback.h"
+#include "core/dom/MutationObserver.h"
+#include "core/dom/MutationObserverInit.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/NodeListsNodeData.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 867 matching lines @@
 
 void HTMLSelectElement::setSuggestedIndex(int suggestedIndex)
 {
     m_suggestedIndex = suggestedIndex;
 
     if (LayoutObject* layoutObject = this->layoutObject())  {
         layoutObject->updateFromElement();
         scrollToOption(item(listToOptionIndex(suggestedIndex)));
     }
     if (popupIsVisible())
-        m_popup->updateFromElement();
+        m_popup->updateFromElement(PopupMenu::BySelectionChange);
 }
 
 void HTMLSelectElement::scrollToOption(HTMLOptionElement* option)
 {
     if (!option)
         return;
     if (usesMenuList())
         return;
     bool hasPendingTask = m_optionToScrollTo;
     // We'd like to keep an HTMLOptionElement reference rather than the index of
@@ skipping 101 matching lines @@
             setActiveSelectionAnchor(element);
         if (!m_activeSelectionEnd || shouldDeselect)
             setActiveSelectionEnd(element);
     }
 
     // For the menu list case, this is what makes the selected element appear.
     if (LayoutObject* layoutObject = this->layoutObject())
         layoutObject->updateFromElement();
     // PopupMenu::updateFromElement() posts an O(N) task.
     if (popupIsVisible())
-        m_popup->updateFromElement();
+        m_popup->updateFromElement(PopupMenu::BySelectionChange);
 
     scrollToSelection();
     setNeedsValidityCheck();
 
     if (usesMenuList()) {
         if (flags & DispatchInputAndChangeEvent)
             dispatchInputAndChangeEventForMenuList();
         else
             m_lastOnChangeOption = element;
         if (LayoutObject* layoutObject = this->layoutObject()) {
@@ skipping 759 matching lines @@
 }
 
 DEFINE_TRACE(HTMLSelectElement)
 {
     visitor->trace(m_listItems);
     visitor->trace(m_lastOnChangeOption);
     visitor->trace(m_activeSelectionAnchor);
     visitor->trace(m_activeSelectionEnd);
     visitor->trace(m_optionToScrollTo);
     visitor->trace(m_popup);
+    visitor->trace(m_popupUpdater);
     HTMLFormControlElementWithState::trace(visitor);
 }
 
 void HTMLSelectElement::didAddUserAgentShadowRoot(ShadowRoot& root)
 {
     HTMLContentElement* content = HTMLContentElement::create(document());
     content->setAttribute(selectAttr, "option,optgroup,hr");
     root.appendChild(content);
 }
 
@@ skipping 56 matching lines @@
 LayoutUnit HTMLSelectElement::clientPaddingRight() const
 {
     if (layoutObject() && layoutObject()->isMenuList())
         return toLayoutMenuList(layoutObject())->clientPaddingRight();
     return LayoutUnit();
 }
 
 void HTMLSelectElement::popupDidHide()
 {
     m_popupIsVisible = false;
+    unobserveTreeMutation();
     if (AXObjectCache* cache = document().existingAXObjectCache()) {
         if (layoutObject() && layoutObject()->isMenuList())
             cache->didHideMenuListPopup(toLayoutMenuList(layoutObject()));
     }
 }
 
 void HTMLSelectElement::setIndexToSelectOnCancel(int listIndex)
 {
     m_indexToSelectOnCancel = listIndex;
     if (layoutObject())
@@ skipping 39 matching lines @@
     if (document().frameHost()->chromeClient().hasOpenedPopup())
         return;
     if (!layoutObject() || !layoutObject()->isMenuList())
         return;
     if (elementRectRelativeToViewport().isEmpty())
         return;
 
     if (!m_popup)
         m_popup = document().frameHost()->chromeClient().openPopupMenu(*document().frame(), *this);
     m_popupIsVisible = true;
+    observeTreeMutation();
 
     LayoutMenuList* menuList = toLayoutMenuList(layoutObject());
     m_popup->show();
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->didShowMenuListPopup(menuList);
 }
 
 void HTMLSelectElement::hidePopup()
 {
     if (m_popup)
         m_popup->hide();
 }
 
 void HTMLSelectElement::didRecalcStyle(StyleRecalcChange change)
 {
     HTMLFormControlElementWithState::didRecalcStyle(change);
     if (popupIsVisible())
-        m_popup->updateFromElement();
+        m_popup->updateFromElement(PopupMenu::ByStyleChange);
 }
 
 void HTMLSelectElement::detach(const AttachContext& context)
 {
     HTMLFormControlElementWithState::detach(context);
     if (m_popup)
         m_popup->disconnectClient();
     m_popupIsVisible = false;
     m_popup = nullptr;
+    unobserveTreeMutation();
 }
 
 void HTMLSelectElement::resetTypeAheadSessionForTesting()
 {
     m_typeAhead.resetSession();
 }
 
+// PopupUpdater notifies updates of the specified SELECT element subtree to
+// a PopupMenu object.
+class HTMLSelectElement::PopupUpdater : public MutationCallback {
+public:
+    explicit PopupUpdater(HTMLSelectElement&);
+    DECLARE_VIRTUAL_TRACE();
+
+    void dispose()
+    {
+        m_observer->disconnect();
+    }
+
+private:
+    void call(const HeapVector<Member<MutationRecord>>&, MutationObserver*) override
+    {
+        m_select->didMutateSubtree();
+    }
+
+    ExecutionContext* getExecutionContext() const override
+    {
+        return &m_select->document();
+    }
+
+    Member<HTMLSelectElement> m_select;
+    Member<MutationObserver> m_observer;
+};
+
+HTMLSelectElement::PopupUpdater::PopupUpdater(HTMLSelectElement& select)
+    : m_select(select)
+{
+    m_observer = MutationObserver::create(this);
+    MutationObserverInit init;
+    init.setAttributes(true);
+    init.setCharacterData(true);
+    init.setChildList(true);
+    init.setSubtree(true);
+    m_observer->observe(&select, init, ASSERT_NO_EXCEPTION);
+}
+
+DEFINE_TRACE(HTMLSelectElement::PopupUpdater)
+{
+    visitor->trace(m_select);
+    visitor->trace(m_observer);
+    MutationCallback::trace(visitor);
+}
+
+void HTMLSelectElement::observeTreeMutation()
+{
+    DCHECK(!m_popupUpdater);
+    m_popupUpdater = new PopupUpdater(*this);
+}
+
+void HTMLSelectElement::unobserveTreeMutation()
+{
+    if (!m_popupUpdater)
+        return;
+    m_popupUpdater->dispose();
+    m_popupUpdater = nullptr;
+}
+
+void HTMLSelectElement::didMutateSubtree()
+{
+    DCHECK(popupIsVisible());
+    DCHECK(m_popup);
+    m_popup->updateFromElement(PopupMenu::ByDOMChange);
+}
+
 } // namespace blink