Fix style errors in PopupContainer and PopupListBox.

Source/core/platform/chromium/PopupListBox.cpp

 /*
  * Copyright (c) 2011, 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #include "config.h"
 #include "core/platform/chromium/PopupListBox.h"
 
-#include <ctype.h>
-#include <limits>
 #include "CSSValueKeywords.h"
 #include "RuntimeEnabledFeatures.h"
 #include "core/platform/PlatformGestureEvent.h"
 #include "core/platform/PlatformKeyboardEvent.h"
 #include "core/platform/PlatformMouseEvent.h"
 #include "core/platform/PlatformScreen.h"
 #include "core/platform/PlatformTouchEvent.h"
 #include "core/platform/PlatformWheelEvent.h"
 #include "core/platform/PopupMenuClient.h"
 #include "core/platform/ScrollbarTheme.h"
 #include "core/platform/chromium/FramelessScrollViewClient.h"
 #include "core/platform/chromium/KeyboardCodes.h"
 #include "core/platform/chromium/PopupContainer.h"
 #include "core/platform/chromium/PopupMenuChromium.h"
 #include "core/platform/graphics/Font.h"
 #include "core/platform/graphics/FontSelector.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/platform/graphics/IntRect.h"
 #include "core/platform/graphics/StringTruncator.h"
 #include "core/platform/graphics/TextRun.h"
 #include "core/rendering/RenderTheme.h"
-#include <wtf/CurrentTime.h>
+#include "wtf/ASCIICType.h"
+#include "wtf/CurrentTime.h"
+#include <limits>
 
 namespace WebCore {
 
-using namespace std;
-using namespace WTF;
-using namespace Unicode;
+using namespace WTF::Unicode;
+
+static const int labelToIconPadding = 5;
+// Padding height put at the top and bottom of each line.
+static const int autofillLinePaddingHeight = 3;
+const int PopupListBox::defaultMaxHeight = 500;
+static const int maxVisibleRows = 20;
+static const int minEndOfLinePadding = 2;
+static const int textToLabelPadding = 10;
+static const TimeStamp typeAheadTimeoutMs = 1000;
 
 PopupListBox::PopupListBox(PopupMenuClient* client, const PopupContainerSettings& settings)
     : m_settings(settings)
     , m_originalIndex(0)
     , m_selectedIndex(0)
     , m_acceptedIndexOnAbandon(-1)
     , m_visibleRows(0)
     , m_baseWidth(0)
-    , m_maxHeight(kMaxHeight)
+    , m_maxHeight(defaultMaxHeight)
     , m_popupClient(client)
     , m_repeatingChar(0)
     , m_lastCharTime(0)
     , m_maxWindowWidth(std::numeric_limits<int>::max())
 {
     setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 }
 
 bool PopupListBox::handleMouseDownEvent(const PlatformMouseEvent& event)
 {
@@ skipping 41 matching lines @@
 {
     if (m_capturingScrollbar) {
         m_capturingScrollbar->mouseUp(event);
         m_capturingScrollbar = 0;
         return true;
     }
 
     if (!isPointInBounds(event.position()))
         return true;
 
-    // Need to check before calling acceptIndex(), because m_popupClient might be removed in acceptIndex() calling because of event handler.
+    // Need to check before calling acceptIndex(), because m_popupClient might
+    // be removed in acceptIndex() calling because of event handler.
     bool isSelectPopup = m_popupClient->menuStyle().menuType() == PopupMenuStyle::SelectPopup;
     if (acceptIndex(pointToRowIndex(event.position())) && m_focusedNode && isSelectPopup) {
         m_focusedNode->dispatchMouseEvent(event, eventNames().mouseupEvent);
         m_focusedNode->dispatchMouseEvent(event, eventNames().clickEvent);
 
-        // Clear m_focusedNode here, because we cannot clear in hidePopup() which is called before dispatchMouseEvent() is called.
+        // Clear m_focusedNode here, because we cannot clear in hidePopup()
+        // which is called before dispatchMouseEvent() is called.
         m_focusedNode = 0;
     }
 
     return true;
 }
 
 bool PopupListBox::handleWheelEvent(const PlatformWheelEvent& event)
 {
     if (!isPointInBounds(event.position())) {
         abandon();
@@ skipping 57 matching lines @@
     case VKEY_RETURN:
         if (m_selectedIndex == -1)  {
             hidePopup();
             // Don't eat the enter if nothing is selected.
             return false;
         }
         acceptIndex(m_selectedIndex); // may delete this
         return true;
     case VKEY_UP:
     case VKEY_DOWN:
-        // We have to forward only shift + up combination to focused node when autofill popup.
-        // Because all characters from the cursor to the start of the text area should selected when you press shift + up arrow.
+        // We have to forward only shift + up combination to focused node when
+        // autofill popup. Because all characters from the cursor to the start
+        // of the text area should selected when you press shift + up arrow.
         // shift + down should be the similar way to shift + up.
         if (event.modifiers() && m_popupClient->menuStyle().menuType() == PopupMenuStyle::AutofillPopup)
             m_focusedNode->dispatchKeyEvent(event);
         else if (event.windowsVirtualKeyCode() == VKEY_UP)
             selectPreviousRow();
         else
             selectNextRow();
         break;
     case VKEY_PRIOR:
         adjustSelectedIndex(-m_visibleRows);
@@ skipping 51 matching lines @@
     return parent() ? parent()->hostWindow() : 0;
 }
 
 // From HTMLSelectElement.cpp
 static String stripLeadingWhiteSpace(const String& string)
 {
     int length = string.length();
     int i;
     for (i = 0; i < length; ++i)
         if (string[i] != noBreakSpace
-            && (string[i] <= 0x7F ? !isspace(string[i]) : (direction(string[i]) != WhiteSpaceNeutral)))
+            && (string[i] <= 0x7F ? !isASCIISpace(string[i]) : (direction(string[i]) != WhiteSpaceNeutral)))
             break;
 
     return string.substring(i, length - i);
 }
 
 // From HTMLSelectElement.cpp, with modifications
 void PopupListBox::typeAheadFind(const PlatformKeyboardEvent& event)
 {
     TimeStamp now = static_cast<TimeStamp>(currentTime() * 1000.0f);
     TimeStamp delta = now - m_lastCharTime;
 
     // Reset the time when user types in a character. The time gap between
     // last character and the current character is used to indicate whether
     // user typed in a string or just a character as the search prefix.
     m_lastCharTime = now;
 
     UChar c = event.windowsVirtualKeyCode();
 
     String prefix;
     int searchStartOffset = 1;
-    if (delta > kTypeAheadTimeoutMs) {
+    if (delta > typeAheadTimeoutMs) {
         m_typedString = prefix = String(&c, 1);
         m_repeatingChar = c;
     } else {
         m_typedString.append(c);
 
-        if (c == m_repeatingChar)
-            // The user is likely trying to cycle through all the items starting with this character, so just search on the character
+        if (c == m_repeatingChar) {
+            // The user is likely trying to cycle through all the items starting
+            // with this character, so just search on the character.
             prefix = String(&c, 1);
-        else {
+        } else {
             m_repeatingChar = 0;
             prefix = m_typedString;
             searchStartOffset = 0;
         }
     }
 
-    // Compute a case-folded copy of the prefix string before beginning the search for
-    // a matching element. This code uses foldCase to work around the fact that
-    // String::startWith does not fold non-ASCII characters. This code can be changed
-    // to use startWith once that is fixed.
+    // Compute a case-folded copy of the prefix string before beginning the
+    // search for a matching element. This code uses foldCase to work around the
+    // fact that String::startWith does not fold non-ASCII characters. This code
+    // can be changed to use startWith once that is fixed.
     String prefixWithCaseFolded(prefix.foldCase());
     int itemCount = numItems();
     int index = (max(0, m_selectedIndex) + searchStartOffset) % itemCount;
     for (int i = 0; i < itemCount; i++, index = (index + 1) % itemCount) {
         if (!isSelectableItem(index))
             continue;
 
         if (stripLeadingWhiteSpace(m_items[index]->label).foldCase().startsWith(prefixWithCaseFolded)) {
             selectIndex(index);
             return;
         }
     }
 }
 
 void PopupListBox::paint(GraphicsContext* gc, const IntRect& rect)
 {
-    // adjust coords for scrolled frame
+    // Adjust coords for scrolled frame.
     IntRect r = intersection(rect, frameRect());
     int tx = x() - scrollX();
     int ty = y() - scrollY();
 
     r.move(-tx, -ty);
 
-    // set clip rect to match revised damage rect
+    // Set clip rect to match revised damage rect.
     gc->save();
     gc->translate(static_cast<float>(tx), static_cast<float>(ty));
     gc->clip(r);
 
     // FIXME: Can we optimize scrolling to not require repainting the entire
     // window? Should we?
     for (int i = 0; i < numItems(); ++i)
         paintRow(gc, r, i);
 
     // Special case for an empty popup.
@@ skipping 81 matching lines @@
     // Prepare text to be drawn.
     String itemText = m_popupClient->itemText(rowIndex);
     String itemLabel = m_popupClient->itemLabel(rowIndex);
     String itemIcon = m_popupClient->itemIcon(rowIndex);
     if (m_settings.restrictWidthOfListBox) { // Truncate strings to fit in.
         // FIXME: We should leftTruncate for the rtl case.
         // StringTruncator::leftTruncate would have to be implemented.
         String str = StringTruncator::rightTruncate(itemText, maxWidth, itemFont);
         if (str != itemText) {
             itemText = str;
-            // Don't display the label or icon, we already don't have enough room for the item text.
+            // Don't display the label or icon, we already don't have enough
+            // room for the item text.
             itemLabel = "";
             itemIcon = "";
         } else if (!itemLabel.isEmpty()) {
-            int availableWidth = maxWidth - kTextToLabelPadding -
-                StringTruncator::width(itemText, itemFont);
+            int availableWidth = maxWidth - textToLabelPadding - StringTruncator::width(itemText, itemFont);
             itemLabel = StringTruncator::rightTruncate(itemLabel, availableWidth, itemFont);
         }
     }
 
     // Prepare the directionality to draw text.
     TextRun textRun(itemText, 0, 0, TextRun::AllowTrailingExpansion, style.textDirection(), style.hasTextDirectionOverride());
     // If the text is right-to-left, make it right-aligned by adjusting its
     // beginning position.
     if (rightAligned)
         textX += maxWidth - itemFont.width(textRun);
 
     // Draw the item text.
     int textY = rowRect.y() + itemFont.fontMetrics().ascent() + (rowRect.height() - itemFont.fontMetrics().height()) / 2;
     TextRunPaintInfo textRunPaintInfo(textRun);
     textRunPaintInfo.bounds = rowRect;
     gc->drawBidiText(itemFont, textRunPaintInfo, IntPoint(textX, textY));
 
     // We are using the left padding as the right padding includes room for the scroll-bar which
     // does not show in this case.
     int rightPadding = max<int>(0, m_popupClient->clientPaddingLeft() - m_popupClient->clientInsetLeft());
     int remainingWidth = rowRect.width() - rightPadding;
 
     // Draw the icon if applicable.
     RefPtr<Image> image(Image::loadPlatformResource(itemIcon.utf8().data()));
     if (image && !image->isNull()) {
         IntRect imageRect = image->rect();
-        remainingWidth -= (imageRect.width() + kLabelToIconPadding);
+        remainingWidth -= (imageRect.width() + labelToIconPadding);
         imageRect.setX(rowRect.width() - rightPadding - imageRect.width());
         imageRect.setY(rowRect.y() + (rowRect.height() - imageRect.height()) / 2);
         gc->drawImage(image.get(), ColorSpaceDeviceRGB, imageRect);
     }
 
     // Draw the the label if applicable.
     if (itemLabel.isEmpty())
         return;
 
     // Autofill label is 0.9 smaller than regular font size.
@@ skipping 130 matching lines @@
     // Separator row height is the same size as itself.
     if (m_popupClient->itemIsSeparator(index))
         return max(separatorHeight, minimumHeight);
 
     String icon = m_popupClient->itemIcon(index);
     RefPtr<Image> image(Image::loadPlatformResource(icon.utf8().data()));
 
     int fontHeight = getRowFont(index).fontMetrics().height();
     int iconHeight = (image && !image->isNull()) ? image->rect().height() : 0;
 
-    int linePaddingHeight = m_popupClient->menuStyle().menuType() == PopupMenuStyle::AutofillPopup ? kLinePaddingHeight : 0;
+    int linePaddingHeight = m_popupClient->menuStyle().menuType() == PopupMenuStyle::AutofillPopup ? autofillLinePaddingHeight : 0;
     int calculatedRowHeight = max(fontHeight, iconHeight) + linePaddingHeight * 2;
     return max(calculatedRowHeight, minimumHeight);
 }
 
 IntRect PopupListBox::getRowBounds(int index)
 {
     if (index < 0)
         return IntRect(0, 0, visibleWidth(), getRowHeight(index));
 
     return IntRect(0, m_items[index]->yOffset, visibleWidth(), getRowHeight(index));
@@ skipping 65 matching lines @@
     }
 
     // No row is selected, jump to the last item.
     selectIndex(numItems() - 1);
     scrollToRevealSelection();
 }
 
 void PopupListBox::adjustSelectedIndex(int delta)
 {
     int targetIndex = m_selectedIndex + delta;
-    targetIndex = min(max(targetIndex, 0), numItems() - 1);
+    targetIndex = std::min(std::max(targetIndex, 0), numItems() - 1);
     if (!isSelectableItem(targetIndex)) {
         // We didn't land on an option. Try to find one.
         // We try to select the closest index to target, prioritizing any in
         // the range [current, target].
 
         int dir = delta > 0 ? 1 : -1;
         int testIndex = m_selectedIndex;
         int bestIndex = m_selectedIndex;
         bool passedTarget = false;
         while (testIndex >= 0 && testIndex < numItems()) {
@@ skipping 83 matching lines @@
         Font itemFont = getRowFont(i);
         String text = m_popupClient->itemText(i);
         String label = m_popupClient->itemLabel(i);
         String icon = m_popupClient->itemIcon(i);
         RefPtr<Image> iconImage(Image::loadPlatformResource(icon.utf8().data()));
         int width = 0;
         if (!text.isEmpty())
             width = itemFont.width(TextRun(text));
         if (!label.isEmpty()) {
             if (width > 0)
-                width += kTextToLabelPadding;
+                width += textToLabelPadding;
             width += itemFont.width(TextRun(label));
         }
         if (iconImage && !iconImage->isNull()) {
             if (width > 0)
-                width += kLabelToIconPadding;
+                width += labelToIconPadding;
             width += iconImage->rect().width();
         }
 
         baseWidth = max(baseWidth, width);
-        // FIXME: http://b/1210481 We should get the padding of individual option elements.
+        // FIXME: http://b/1210481 We should get the padding of individual
+        // option elements.
         paddingWidth = max<int>(paddingWidth,
             m_popupClient->clientPaddingLeft() + m_popupClient->clientPaddingRight());
         lineEndPaddingWidth = max<int>(lineEndPaddingWidth,
             isRightAligned ? m_popupClient->clientPaddingLeft() : m_popupClient->clientPaddingRight());
     }
 
     // Calculate scroll bar width.
     int windowHeight = 0;
-    m_visibleRows = min(numItems(), kMaxVisibleRows);
+    m_visibleRows = std::min(numItems(), maxVisibleRows);
 
     for (int i = 0; i < m_visibleRows; ++i) {
         int rowHeight = getRowHeight(i);
 
         // Only clip the window height for non-Mac platforms.
         if (windowHeight + rowHeight > m_maxHeight) {
             m_visibleRows = i;
             break;
         }
 
         windowHeight += rowHeight;
     }
 
     // Set our widget and scrollable contents sizes.
     int scrollbarWidth = 0;
     if (m_visibleRows < numItems()) {
         scrollbarWidth = ScrollbarTheme::theme()->scrollbarThickness();
 
-        // Use kMinEndOfLinePadding when there is a scrollbar so that we use
-        // as much as (lineEndPaddingWidth - kMinEndOfLinePadding) padding
+        // Use minEndOfLinePadding when there is a scrollbar so that we use
+        // as much as (lineEndPaddingWidth - minEndOfLinePadding) padding
         // space for scrollbar and allow user to use CSS padding to make the
         // popup listbox align with the select element.
-        paddingWidth = paddingWidth - lineEndPaddingWidth + kMinEndOfLinePadding;
+        paddingWidth = paddingWidth - lineEndPaddingWidth + minEndOfLinePadding;
     }
 
     int windowWidth;
     int contentWidth;
     if (m_settings.restrictWidthOfListBox) {
         windowWidth = m_baseWidth;
         contentWidth = m_baseWidth - scrollbarWidth;
     } else {
         windowWidth = baseWidth + scrollbarWidth + paddingWidth;
         if (windowWidth > m_maxWindowWidth) {
@@ skipping 31 matching lines @@
 {
     return numItems() && IntRect(0, 0, width(), height()).contains(point);
 }
 
 int PopupListBox::popupContentHeight() const
 {
     return height();
 }
 
 } // namespace WebCore