Change HTMLSelectElement::setSelectedIndex to use enums instead of bools
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 2 Nov 2011 02:47:18 +0000 (02:47 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 2 Nov 2011 02:47:18 +0000 (02:47 +0000)
https://bugs.webkit.org/show_bug.cgi?id=70184

Reviewed by Kent Tamura.

Source/WebCore:

Refactoring that does not require new tests.

* bindings/objc/DOMHTML.mm:
(-[DOMHTMLSelectElement _activateItemAtIndex:]): Replaced setSelectedIndexByUser
call with a call to the renamed optionSelectedByUser, also removed one argument.
(-[DOMHTMLSelectElement _activateItemAtIndex:allowMultipleSelection:]): Ditto.

* html/HTMLOptionElement.cpp:
(WebCore::HTMLOptionElement::setSelected): Replaced setSelectedIndex call with a
call to the new optionSelectionStateChanged function.
(WebCore::HTMLOptionElement::insertedIntoTree): Ditto.

* html/HTMLSelectElement.cpp:
(WebCore::HTMLSelectElement::HTMLSelectElement): Updated since m_userDrivenChange
was renamed to m_isProcessingUserDrivenChange.
(WebCore::HTMLSelectElement::optionSelectedByUser): Removed deselect argument,
which was always true for all callers. Updated comment.
(WebCore::HTMLSelectElement::hasPlaceholderLabelOption): Updated comment.
(WebCore::HTMLSelectElement::setOption): Call the new optionSelectionStateChanged
function. The code used to explicitly ask the function it calls to deselect base
on the value of m_multiple, but that is no longer needed because the selectOption
function itself takes care of that check.
(WebCore::HTMLSelectElement::dispatchChangeEventForMenuList): Renamed this function.
Also updated for name change to m_isProcessingUserDrivenChange.
(WebCore::HTMLSelectElement::setSelectedIndex): Moved the formerly-inlined function
here from the header and changed it to call the renamed selectOption function.
(WebCore::HTMLSelectElement::optionSelectionStateChanged): Added this function.
It is used by callers that were previously using setSelectedIndex and passing
"false" for the deselect argument. It's better now that setSelectedIndex is now a
pure DOM setter function without the multiple purposes it had before. This function
now has the logic that handles the special handling when deselecting an option,
which used to be at the top of the next function.
(WebCore::HTMLSelectElement::selectOption): Renamed this from setSelectedIndex.
Replaced boolean arguments with flags. Removed code to handle the special case
when we deselect an option; that's now handled in the optionSelectionStateChanged
function. Added an assertion to replace a comment and updated for other renaming.
(WebCore::HTMLSelectElement::dispatchBlurEvent): Updated for name change.
(WebCore::HTMLSelectElement::platformHandleKeydownEvent): Ditto.
(WebCore::HTMLSelectElement::menuListDefaultEventHandler): Changed to call the
new selectOption function and also updated for other name changes.
(WebCore::HTMLSelectElement::typeAheadFind): Ditto.
(WebCore::HTMLSelectElement::accessKeySetSelectedIndex): Ditto.

* html/HTMLSelectElement.h: Changed the setSelectedIndex to be a pure setter
function for the selectedIndex DOM property. Added a optionSelectedByUser function
for the other use of setSelectedIndex, but removed the always true "deselect"
argument from it. Added a optionSelectionStateChanged function for use in the
HTMLOptionElement implementation. Renamed menuListOnChange to
dispatchChangeEventForMenuList for clarity. Added a SelectOptionFlag and
SelectOptionFlags type for the arguments to the selectOption function, formerly
implemented as an overload of setSelectedIndex (and called setSelectedIndexInternal
before that). Renamed m_userDrivenChange to m_isProcessingUserDrivenChange.

* rendering/RenderMenuList.cpp:
(WebCore::RenderMenuList::valueChanged): Replaced setSelectedIndexByUser
call with a call to the renamed optionSelectedByUser, also removed one argument.

Source/WebKit/chromium:

* tests/PopupMenuTest.cpp:
(WebKit::TestPopupMenuClient::valueChanged): Replaced setSelectedIndexByUser
call with a call to the renamed optionSelectedByUser, also removed one argument.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@99035 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog
Source/WebCore/bindings/objc/DOMHTML.mm
Source/WebCore/html/HTMLOptionElement.cpp
Source/WebCore/html/HTMLSelectElement.cpp
Source/WebCore/html/HTMLSelectElement.h
Source/WebCore/rendering/RenderMenuList.cpp
Source/WebKit/chromium/ChangeLog
Source/WebKit/chromium/tests/PopupMenuTest.cpp

index 97ef78a..f4d3bff 100644 (file)
@@ -1,3 +1,67 @@
+2011-11-01  Darin Adler  <darin@apple.com>
+
+        Change HTMLSelectElement::setSelectedIndex to use enums instead of bools
+        https://bugs.webkit.org/show_bug.cgi?id=70184
+
+        Reviewed by Kent Tamura.
+
+        Refactoring that does not require new tests.
+
+        * bindings/objc/DOMHTML.mm:
+        (-[DOMHTMLSelectElement _activateItemAtIndex:]): Replaced setSelectedIndexByUser
+        call with a call to the renamed optionSelectedByUser, also removed one argument.
+        (-[DOMHTMLSelectElement _activateItemAtIndex:allowMultipleSelection:]): Ditto.
+
+        * html/HTMLOptionElement.cpp:
+        (WebCore::HTMLOptionElement::setSelected): Replaced setSelectedIndex call with a
+        call to the new optionSelectionStateChanged function.
+        (WebCore::HTMLOptionElement::insertedIntoTree): Ditto.
+
+        * html/HTMLSelectElement.cpp:
+        (WebCore::HTMLSelectElement::HTMLSelectElement): Updated since m_userDrivenChange
+        was renamed to m_isProcessingUserDrivenChange.
+        (WebCore::HTMLSelectElement::optionSelectedByUser): Removed deselect argument,
+        which was always true for all callers. Updated comment.
+        (WebCore::HTMLSelectElement::hasPlaceholderLabelOption): Updated comment.
+        (WebCore::HTMLSelectElement::setOption): Call the new optionSelectionStateChanged
+        function. The code used to explicitly ask the function it calls to deselect base
+        on the value of m_multiple, but that is no longer needed because the selectOption
+        function itself takes care of that check.
+        (WebCore::HTMLSelectElement::dispatchChangeEventForMenuList): Renamed this function.
+        Also updated for name change to m_isProcessingUserDrivenChange.
+        (WebCore::HTMLSelectElement::setSelectedIndex): Moved the formerly-inlined function
+        here from the header and changed it to call the renamed selectOption function.
+        (WebCore::HTMLSelectElement::optionSelectionStateChanged): Added this function.
+        It is used by callers that were previously using setSelectedIndex and passing
+        "false" for the deselect argument. It's better now that setSelectedIndex is now a
+        pure DOM setter function without the multiple purposes it had before. This function
+        now has the logic that handles the special handling when deselecting an option,
+        which used to be at the top of the next function.
+        (WebCore::HTMLSelectElement::selectOption): Renamed this from setSelectedIndex.
+        Replaced boolean arguments with flags. Removed code to handle the special case
+        when we deselect an option; that's now handled in the optionSelectionStateChanged
+        function. Added an assertion to replace a comment and updated for other renaming.
+        (WebCore::HTMLSelectElement::dispatchBlurEvent): Updated for name change.
+        (WebCore::HTMLSelectElement::platformHandleKeydownEvent): Ditto.
+        (WebCore::HTMLSelectElement::menuListDefaultEventHandler): Changed to call the
+        new selectOption function and also updated for other name changes.
+        (WebCore::HTMLSelectElement::typeAheadFind): Ditto.
+        (WebCore::HTMLSelectElement::accessKeySetSelectedIndex): Ditto.
+
+        * html/HTMLSelectElement.h: Changed the setSelectedIndex to be a pure setter
+        function for the selectedIndex DOM property. Added a optionSelectedByUser function
+        for the other use of setSelectedIndex, but removed the always true "deselect"
+        argument from it. Added a optionSelectionStateChanged function for use in the
+        HTMLOptionElement implementation. Renamed menuListOnChange to
+        dispatchChangeEventForMenuList for clarity. Added a SelectOptionFlag and
+        SelectOptionFlags type for the arguments to the selectOption function, formerly
+        implemented as an overload of setSelectedIndex (and called setSelectedIndexInternal
+        before that). Renamed m_userDrivenChange to m_isProcessingUserDrivenChange.
+
+        * rendering/RenderMenuList.cpp:
+        (WebCore::RenderMenuList::valueChanged): Replaced setSelectedIndexByUser
+        call with a call to the renamed optionSelectedByUser, also removed one argument.
+
 2011-11-01  Sam Weinig  <sam@webkit.org>
 
         Implement __lookupGetter__/__lookupSetter__ in terms of getPropertyDescriptor
index 0d94c8d..59cebcb 100644 (file)
 {
     // Use the setSelectedIndexByUser function so a change event will be fired. <rdar://problem/6760590>
     if (WebCore::HTMLSelectElement* select = core(self))
-        select->setSelectedIndexByUser(index, true, true);
+        select->optionSelectedByUser(index, true);
 }
 
 - (void)_activateItemAtIndex:(int)index allowMultipleSelection:(BOOL)allowMultipleSelection
     // If this is a <select multiple> the allowMultipleSelection flag will allow setting multiple
     // selections without clearing the other selections.
     if (WebCore::HTMLSelectElement* select = core(self))
-        select->setSelectedIndexByUser(index, true, true, allowMultipleSelection);
+        select->optionSelectedByUser(index, true, allowMultipleSelection);
 }
 
 @end
index 6bc1419..9654d67 100644 (file)
@@ -229,7 +229,7 @@ void HTMLOptionElement::setSelected(bool selected)
     setSelectedState(selected);
 
     if (HTMLSelectElement* select = ownerSelectElement())
-        select->setSelectedIndex(selected ? index() : -1, false);
+        select->optionSelectionStateChanged(this, selected);
 }
 
 void HTMLOptionElement::setSelectedState(bool selected)
@@ -276,9 +276,10 @@ void HTMLOptionElement::setLabel(const String& label)
 void HTMLOptionElement::setRenderStyle(PassRefPtr<RenderStyle> newStyle)
 {
     m_style = newStyle;
-    if (HTMLSelectElement* select = ownerSelectElement())
+    if (HTMLSelectElement* select = ownerSelectElement()) {
         if (RenderObject* renderer = select->renderer())
             renderer->repaint();
+    }
 }
 
 RenderStyle* HTMLOptionElement::nonRendererRenderStyle() const
@@ -305,8 +306,10 @@ void HTMLOptionElement::insertedIntoTree(bool deep)
         select->setRecalcListItems();
         // Do not call selected() since calling updateListItemSelectedStates()
         // at this time won't do the right thing. (Why, exactly?)
+        // FIXME: Might be better to call this unconditionally, always passing m_isSelected,
+        // rather than only calling it if we are selected.
         if (m_isSelected)
-            select->setSelectedIndex(index(), false);
+            select->optionSelectionStateChanged(this, true);
         select->scrollToSelection();
     }
 
index 623c35f..4986288 100644 (file)
@@ -83,7 +83,7 @@ HTMLSelectElement::HTMLSelectElement(const QualifiedName& tagName, Document* doc
     , m_activeSelectionAnchorIndex(-1)
     , m_activeSelectionEndIndex(-1)
     , m_repeatingChar(0)
-    , m_userDrivenChange(false)
+    , m_isProcessingUserDrivenChange(false)
     , m_multiple(false)
     , m_activeSelectionState(false)
     , m_shouldRecalcListItems(false)
@@ -110,10 +110,10 @@ void HTMLSelectElement::deselectItems(HTMLOptionElement* excludeElement)
     setNeedsValidityCheck();
 }
 
-void HTMLSelectElement::setSelectedIndexByUser(int optionIndex, bool deselect, bool fireOnChangeNow, bool allowMultipleSelection)
+void HTMLSelectElement::optionSelectedByUser(int optionIndex, bool fireOnChangeNow, bool allowMultipleSelection)
 {
-    // List box selects can fire onchange events through user interaction, such as
-    // mousedown events. This allows that same behavior programmatically.
+    // User interaction such as mousedown events can cause list box select elements to send change events.
+    // This produces that same behavior for changes triggered by other code running on behalf of the user.
     if (!usesMenuList()) {
         updateSelectedState(optionIndex, allowMultipleSelection, false);
         setNeedsValidityCheck();
@@ -123,20 +123,20 @@ void HTMLSelectElement::setSelectedIndexByUser(int optionIndex, bool deselect, b
     }
 
     // Bail out if this index is already the selected one, to avoid running unnecessary JavaScript that can mess up
-    // autofill, when there is no actual change (see https://bugs.webkit.org/show_bug.cgi?id=35256 and rdar://7467917 ).
-    // Perhaps this logic could be moved into SelectElement, but some callers of SelectElement::setSelectedIndex()
-    // seem to expect it to fire its change event even when the index was already selected.
+    // autofill when there is no actual change (see https://bugs.webkit.org/show_bug.cgi?id=35256 and <rdar://7467917>).
+    // The selectOption function does not behave this way, possibly because other callers need a change event even
+    // in cases where the selected option is not change.
     if (optionIndex == selectedIndex())
         return;
-    
-    setSelectedIndex(optionIndex, deselect, fireOnChangeNow, true);
+
+    selectOption(optionIndex, DeselectOtherOptions | (fireOnChangeNow ? DispatchChangeEvent : 0) | UserDriven);
 }
 
 bool HTMLSelectElement::hasPlaceholderLabelOption() const
 {
     // The select element has no placeholder label option if it has an attribute "multiple" specified or a display size of non-1.
     // 
-    // The condition "size() > 1" is actually not compliant with the HTML5 spec as of Dec 3, 2010. "size() != 1" is correct.
+    // The condition "size() > 1" is not compliant with the HTML5 spec as of Dec 3, 2010. "size() != 1" is correct.
     // Using "size() > 1" here because size() may be 0 in WebKit.
     // See the discussion at https://bugs.webkit.org/show_bug.cgi?id=43887
     //
@@ -385,7 +385,7 @@ void HTMLSelectElement::setOption(unsigned index, HTMLOptionElement* option, Exc
     ec = 0;
     if (index > maxSelectItems - 1)
         index = maxSelectItems - 1;
-    int diff = index  - length();
+    int diff = index - length();
     HTMLElement* before = 0;
     // Out of array bounds? First insert empty dummies.
     if (diff > 0) {
@@ -399,7 +399,7 @@ void HTMLSelectElement::setOption(unsigned index, HTMLOptionElement* option, Exc
     if (!ec) {
         add(option, before, ec);
         if (diff >= 0 && option->selected())
-            setSelectedIndex(index, !m_multiple);
+            optionSelectionStateChanged(option, true);
     }
 }
 
@@ -618,14 +618,14 @@ void HTMLSelectElement::listBoxOnChange()
         dispatchFormControlChangeEvent();
 }
 
-void HTMLSelectElement::menuListOnChange()
+void HTMLSelectElement::dispatchChangeEventForMenuList()
 {
     ASSERT(usesMenuList());
 
     int selected = selectedIndex();
-    if (m_lastOnChangeIndex != selected && m_userDrivenChange) {
+    if (m_lastOnChangeIndex != selected && m_isProcessingUserDrivenChange) {
         m_lastOnChangeIndex = selected;
-        m_userDrivenChange = false;
+        m_isProcessingUserDrivenChange = false;
         dispatchFormControlChangeEvent();
     }
 }
@@ -746,12 +746,23 @@ int HTMLSelectElement::selectedIndex() const
     return -1;
 }
 
-void HTMLSelectElement::setSelectedIndex(int optionIndex, bool deselect, bool fireOnChangeNow, bool userDrivenChange)
+void HTMLSelectElement::setSelectedIndex(int index)
+{
+    selectOption(index, DeselectOtherOptions);
+}
+
+void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
+{
+    ASSERT(option->ownerSelectElement() == this);
+    if (optionIsSelected)
+        selectOption(option->index());
+    else
+        selectOption(m_multiple ? -1 : nextSelectableListIndex(-1));
+}
+
+void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
 {
-    if (optionIndex == -1 && !deselect && !m_multiple)
-        optionIndex = nextSelectableListIndex(-1);
-    if (!m_multiple)
-        deselect = true;
+    bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
 
     const Vector<HTMLElement*>& items = listItems();
     int listIndex = optionToListIndex(optionIndex);
@@ -760,15 +771,15 @@ void HTMLSelectElement::setSelectedIndex(int optionIndex, bool deselect, bool fi
     if (listIndex >= 0) {
         element = items[listIndex];
         if (element->hasTagName(optionTag)) {
-            if (m_activeSelectionAnchorIndex < 0 || deselect)
+            if (m_activeSelectionAnchorIndex < 0 || shouldDeselect)
                 setActiveSelectionAnchorIndex(listIndex);
-            if (m_activeSelectionEndIndex < 0 || deselect)
+            if (m_activeSelectionEndIndex < 0 || shouldDeselect)
                 setActiveSelectionEndIndex(listIndex);
             toHTMLOptionElement(element)->setSelectedState(true);
         }
     }
 
-    if (deselect)
+    if (shouldDeselect)
         deselectItemsWithoutValidation(element);
 
     // For the menu list case, this is what makes the selected element appear.
@@ -777,13 +788,13 @@ void HTMLSelectElement::setSelectedIndex(int optionIndex, bool deselect, bool fi
 
     scrollToSelection();
 
-    // This only gets called with fireOnChangeNow for menu lists. 
-    if (usesMenuList()) {
-        m_userDrivenChange = userDrivenChange;
-        if (fireOnChangeNow)
-            menuListOnChange();
-        RenderObject* renderer = this->renderer();
-        if (renderer) {
+    if (!usesMenuList())
+        ASSERT(!(flags & DispatchChangeEvent));
+    else {
+        m_isProcessingUserDrivenChange = flags & UserDriven;
+        if (flags & DispatchChangeEvent)
+            dispatchChangeEventForMenuList();
+        if (RenderObject* renderer = this->renderer()) {
             if (usesMenuList())
                 toRenderMenuList(renderer)->didSetSelectedIndex(listIndex);
             else if (renderer->isListBox())
@@ -846,7 +857,7 @@ void HTMLSelectElement::dispatchBlurEvent(PassRefPtr<Node> newFocusedNode)
     // change events for list boxes whenever the selection change is actually made.
     // This matches other browsers' behavior.
     if (usesMenuList())
-        menuListOnChange();
+        dispatchChangeEventForMenuList();
     HTMLFormControlElementWithState::dispatchBlurEvent(newFocusedNode);
 }
 
@@ -969,7 +980,7 @@ bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
                 return true;
 
             // Save the selection so it can be compared to the new selection
-            // when dispatching change events during setSelectedIndex, which
+            // when dispatching change events during selectOption, which
             // gets called from RenderMenuList::valueChanged, which gets called
             // after the user makes a selection from the menu.
             saveLastSelection();
@@ -1022,7 +1033,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
             handled = false;
 
         if (handled && static_cast<size_t>(listIndex) < listItems.size())
-            setSelectedIndex(listToOptionIndex(listIndex), true, false, true);
+            selectOption(listToOptionIndex(listIndex), DeselectOtherOptions | UserDriven);
 
         if (handled)
             event->setDefaultHandled();
@@ -1054,7 +1065,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
                 return;
 
             // Save the selection so it can be compared to the new selection
-            // when dispatching change events during setSelectedIndex, which
+            // when dispatching change events during selectOption, which
             // gets called from RenderMenuList::valueChanged, which gets called
             // after the user makes a selection from the menu.
             saveLastSelection();
@@ -1072,7 +1083,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
                 return;
 
             // Save the selection so it can be compared to the new selection
-            // when dispatching change events during setSelectedIndex, which
+            // when dispatching change events during selectOption, which
             // gets called from RenderMenuList::valueChanged, which gets called
             // after the user makes a selection from the menu.
             saveLastSelection();
@@ -1082,14 +1093,14 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
         } else if (keyCode == '\r') {
             if (form())
                 form()->submitImplicitly(event, false);
-            menuListOnChange();
+            dispatchChangeEventForMenuList();
             handled = true;
         }
 #else
         int listIndex = optionToListIndex(selectedIndex());
         if (keyCode == '\r') {
             // listIndex should already be selected, but this will fire the onchange handler.
-            setSelectedIndex(listToOptionIndex(listIndex), true, true, true);
+            selectOption(listToOptionIndex(listIndex), DeselectOtherOptions | DispatchChangeEvent | UserDriven);
             handled = true;
         }
 #endif
@@ -1105,7 +1116,7 @@ void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
                     menuList->hidePopup();
                 else {
                     // Save the selection so it can be compared to the new
-                    // selection when we call onChange during setSelectedIndex,
+                    // selection when we call onChange during selectOption,
                     // which gets called from RenderMenuList::valueChanged,
                     // which gets called after the user makes a selection from
                     // the menu.
@@ -1398,7 +1409,7 @@ void HTMLSelectElement::typeAheadFind(KeyboardEvent* event)
         // Fold the option string and check if its prefix is equal to the folded prefix.
         String text = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
         if (stripLeadingWhiteSpace(text).foldCase().startsWith(prefixWithCaseFolded)) {
-            setSelectedIndex(listToOptionIndex(index), true, false, true);
+            selectOption(listToOptionIndex(index), DeselectOtherOptions | UserDriven);
             if (!usesMenuList())
                 listBoxOnChange();
 
@@ -1433,12 +1444,12 @@ void HTMLSelectElement::accessKeySetSelectedIndex(int index)
             if (toHTMLOptionElement(element)->selected())
                 toHTMLOptionElement(element)->setSelectedState(false);
             else
-                setSelectedIndex(index, false, true, true);
+                selectOption(index, DispatchChangeEvent | UserDriven);
         }
     }
 
     if (usesMenuList())
-        menuListOnChange();
+        dispatchChangeEventForMenuList();
     else
         listBoxOnChange();
 
index a22c60a..c300fdc 100644 (file)
@@ -41,8 +41,9 @@ public:
     static PassRefPtr<HTMLSelectElement> create(const QualifiedName&, Document*, HTMLFormElement*);
 
     int selectedIndex() const;
-    void setSelectedIndex(int index, bool deselect = true);
-    void setSelectedIndexByUser(int index, bool deselect = true, bool fireOnChangeNow = false, bool allowMultipleSelection = false);
+    void setSelectedIndex(int);
+
+    void optionSelectedByUser(int index, bool dispatchChangeEvent, bool allowMultipleSelection = false);
 
     // For ValidityState
     bool valueMissing() const;
@@ -102,6 +103,9 @@ public:
     void setActiveSelectionEndIndex(int);
     void updateListBoxSelection(bool deselectOtherOptions);
     
+    // For use in the implementation of HTMLOptionElement.
+    void optionSelectionStateChanged(HTMLOptionElement*, bool optionIsSelected);
+    
 protected:
     HTMLSelectElement(const QualifiedName&, Document*, HTMLFormElement*);
 
@@ -130,7 +134,7 @@ private:
 
     virtual void defaultEventHandler(Event*);
 
-    void menuListOnChange();
+    void dispatchChangeEventForMenuList();
     
     void recalcListItems(bool updateSelectedStates = true) const;
 
@@ -145,8 +149,14 @@ private:
 
     bool hasPlaceholderLabelOption() const;
 
-    void setSelectedIndex(int optionIndex, bool deselect, bool fireOnChangeNow, bool userDrivenChange);
-    void deselectItemsWithoutValidation(HTMLElement* excludeElement = 0);
+    enum SelectOptionFlag {
+        DeselectOtherOptions = 1 << 0,
+        DispatchChangeEvent = 1 << 1,
+        UserDriven = 1 << 2,
+    };
+    typedef unsigned SelectOptionFlags;
+    void selectOption(int optionIndex, SelectOptionFlags = 0);
+    void deselectItemsWithoutValidation(HTMLElement* elementToExclude = 0);
     void parseMultipleAttribute(const Attribute*);
     int lastSelectedListIndex() const;
     void updateSelectedState(int listIndex, bool multi, bool shift);
@@ -180,17 +190,12 @@ private:
     int m_activeSelectionAnchorIndex;
     int m_activeSelectionEndIndex;
     UChar m_repeatingChar;
-    bool m_userDrivenChange;
+    bool m_isProcessingUserDrivenChange;
     bool m_multiple;
     bool m_activeSelectionState;
     mutable bool m_shouldRecalcListItems;
 };
 
-inline void HTMLSelectElement::setSelectedIndex(int index, bool deselect)
-{
-    setSelectedIndex(index, deselect, false, false);
-}
-
 inline bool HTMLSelectElement::usesMenuList() const
 {
 #if ENABLE(NO_LISTBOX_RENDERING)
index b84d3cd..6621603 100644 (file)
@@ -325,7 +325,7 @@ void RenderMenuList::valueChanged(unsigned listIndex, bool fireOnChange)
         return;
     
     HTMLSelectElement* select = toHTMLSelectElement(node());
-    select->setSelectedIndexByUser(select->listToOptionIndex(listIndex), true, fireOnChange);
+    select->optionSelectedByUser(select->listToOptionIndex(listIndex), fireOnChange);
 }
 
 #if ENABLE(NO_LISTBOX_RENDERING)
index 4792fdf..c91e2ce 100644 (file)
@@ -1,3 +1,14 @@
+2011-11-01  Darin Adler  <darin@apple.com>
+
+        Change HTMLSelectElement::setSelectedIndex to use enums instead of bools
+        https://bugs.webkit.org/show_bug.cgi?id=70184
+
+        Reviewed by Kent Tamura.
+
+        * tests/PopupMenuTest.cpp:
+        (WebKit::TestPopupMenuClient::valueChanged): Replaced setSelectedIndexByUser
+        call with a call to the renamed optionSelectedByUser, also removed one argument.
+
 2011-11-01  Nat Duca  <nduca@chromium.org>
 
         [chromium] Move resource-releasing logic into CCProxy and cleanup setNeedsCommit
index f8b6b82..069319e 100644 (file)
@@ -75,7 +75,7 @@ public:
         m_selectIndex = listIndex;
         if (m_node) {
             HTMLSelectElement* select = toHTMLSelectElement(m_node);
-            select->setSelectedIndexByUser(select->listToOptionIndex(listIndex), true, fireEvents);
+            select->optionSelectedByUser(select->listToOptionIndex(listIndex), fireEvents);
         }
     }
     virtual void selectionChanged(unsigned, bool) {}