Fix style errors in PopupContainer and PopupListBox.

Source/core/platform/chromium/PopupContainer.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
@@ skipping 13 matching lines @@
  * 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/PopupContainer.h"
 
-#include <limits>
 #include "core/dom/Document.h"
 #include "core/dom/UserGestureIndicator.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
 #include "core/page/Page.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/chromium/FramelessScrollView.h"
 #include "core/platform/chromium/FramelessScrollViewClient.h"
 #include "core/platform/chromium/PopupListBox.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/platform/graphics/IntRect.h"
-
-using namespace std;
+#include <limits>
 
 namespace WebCore {
 
-static const int kBorderSize = 1;
+static const int borderSize = 1;
 
-static PlatformMouseEvent constructRelativeMouseEvent(const PlatformMouseEvent& e,
-                                                      FramelessScrollView* parent,
-                                                      FramelessScrollView* child)
+static PlatformMouseEvent constructRelativeMouseEvent(const PlatformMouseEvent& e, FramelessScrollView* parent, FramelessScrollView* child)
 {
     IntPoint pos = parent->convertSelfToChild(child, e.position());
 
     // FIXME: This is a horrible hack since PlatformMouseEvent has no setters for x/y.
     PlatformMouseEvent relativeEvent = e;
     IntPoint& relativePos = const_cast<IntPoint&>(relativeEvent.position());
     relativePos.setX(pos.x());
     relativePos.setY(pos.y());
     return relativeEvent;
 }
 
-static PlatformWheelEvent constructRelativeWheelEvent(const PlatformWheelEvent& e,
-                                                      FramelessScrollView* parent,
-                                                      FramelessScrollView* child)
+static PlatformWheelEvent constructRelativeWheelEvent(const PlatformWheelEvent& e, FramelessScrollView* parent, FramelessScrollView* child)
 {
     IntPoint pos = parent->convertSelfToChild(child, e.position());
 
     // FIXME: This is a horrible hack since PlatformWheelEvent has no setters for x/y.
     PlatformWheelEvent relativeEvent = e;
     IntPoint& relativePos = const_cast<IntPoint&>(relativeEvent.position());
     relativePos.setX(pos.x());
     relativePos.setY(pos.y());
     return relativeEvent;
 }
 
 // static
-PassRefPtr<PopupContainer> PopupContainer::create(PopupMenuClient* client,
-                                                  PopupType popupType,
-                                                  const PopupContainerSettings& settings)
+PassRefPtr<PopupContainer> PopupContainer::create(PopupMenuClient* client, PopupType popupType, const PopupContainerSettings& settings)
 {
     return adoptRef(new PopupContainer(client, popupType, settings));
 }
 
-PopupContainer::PopupContainer(PopupMenuClient* client,
-                               PopupType popupType,
-                               const PopupContainerSettings& settings)
+PopupContainer::PopupContainer(PopupMenuClient* client, PopupType popupType, const PopupContainerSettings& settings)
     : m_listBox(PopupListBox::create(client, settings))
     , m_settings(settings)
     , m_popupType(popupType)
     , m_popupOpen(false)
 {
     setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 }
 
 PopupContainer::~PopupContainer()
 {
@@ skipping 15 matching lines @@
         unsigned inverseCutoff = std::max(enclosingScreen.x() - inverseWidgetRectInScreen.x(), 0) + std::max(inverseWidgetRectInScreen.maxX() - enclosingScreen.maxX(), 0);
 
         // Accept the inverse popup alignment if the trimmed content gets
         // shorter than that in the original alignment case.
         if (inverseCutoff < originalCutoff)
             widgetRectInScreen = inverseWidgetRectInScreen;
 
         if (widgetRectInScreen.x() < screen.x()) {
             widgetRectInScreen.setWidth(widgetRectInScreen.maxX() - screen.x());
             widgetRectInScreen.setX(screen.x());
-            listBox->setMaxWidthAndLayout(std::max(widgetRectInScreen.width() - kBorderSize * 2, 0));
+            listBox->setMaxWidthAndLayout(std::max(widgetRectInScreen.width() - borderSize * 2, 0));
         } else if (widgetRectInScreen.maxX() > screen.maxX()) {
             widgetRectInScreen.setWidth(screen.maxX() - widgetRectInScreen.x());
-            listBox->setMaxWidthAndLayout(std::max(widgetRectInScreen.width() - kBorderSize * 2, 0));
+            listBox->setMaxWidthAndLayout(std::max(widgetRectInScreen.width() - borderSize * 2, 0));
         }
     }
 
     // Calculate Y axis size.
     if (widgetRectInScreen.maxY() > static_cast<int>(screen.maxY())) {
         if (widgetRectInScreen.y() - widgetRectInScreen.height() - targetControlHeight - transformOffset.height() > 0) {
             // There is enough room to open upwards.
             widgetRectInScreen.move(-transformOffset.width(), -(widgetRectInScreen.height() + targetControlHeight + transformOffset.height()));
         } else {
             // Figure whether upwards or downwards has more room and set the
             // maximum number of items.
             int spaceAbove = widgetRectInScreen.y() - targetControlHeight + transformOffset.height();
             int spaceBelow = screen.maxY() - widgetRectInScreen.y();
             if (spaceAbove > spaceBelow)
                 listBox->setMaxHeight(spaceAbove);
             else
                 listBox->setMaxHeight(spaceBelow);
             listBox->layout();
             needToResizeView = true;
-            widgetRectInScreen.setHeight(listBox->popupContentHeight() + kBorderSize * 2);
+            widgetRectInScreen.setHeight(listBox->popupContentHeight() + borderSize * 2);
             // Move WebWidget upwards if necessary.
             if (spaceAbove > spaceBelow)
                 widgetRectInScreen.move(-transformOffset.width(), -(widgetRectInScreen.height() + targetControlHeight + transformOffset.height()));
         }
     }
     return widgetRectInScreen;
 }
 
 IntRect PopupContainer::layoutAndCalculateWidgetRect(int targetControlHeight, const IntSize& transformOffset, const IntPoint& popupInitialCoordinate)
 {
-    // Reset the max width and height to their default values, they will be recomputed below
-    // if necessary.
-    m_listBox->setMaxHeight(kMaxHeight);
+    // Reset the max width and height to their default values, they will be
+    // recomputed below if necessary.
+    m_listBox->setMaxHeight(PopupListBox::defaultMaxHeight);
     m_listBox->setMaxWidth(std::numeric_limits<int>::max());
 
     // Lay everything out to figure out our preferred size, then tell the view's
     // WidgetClient about it. It should assign us a client.
     m_listBox->layout();
     fitToListBox();
     bool isRTL = this->isRTL();
 
-    // Compute the starting x-axis for a normal RTL or right-aligned LTR dropdown. For those,
-    // the right edge of dropdown box should be aligned with the right edge of <select>/<input> element box,
-    // and the dropdown box should be expanded to the left if more space is needed.
-    // m_originalFrameRect.width() is the width of the target <select>/<input> element.
-    int rtlOffset = m_controlPosition.p2().x() - m_controlPosition.p1().x() - (m_listBox->width() + kBorderSize * 2);
+    // Compute the starting x-axis for a normal RTL or right-aligned LTR
+    // dropdown. For those, the right edge of dropdown box should be aligned
+    // with the right edge of <select>/<input> element box, and the dropdown box
+    // should be expanded to the left if more space is needed.
+    // m_originalFrameRect.width() is the width of the target <select>/<input>
+    // element.
+    int rtlOffset = m_controlPosition.p2().x() - m_controlPosition.p1().x() - (m_listBox->width() + borderSize * 2);
     int rightOffset = isRTL ? rtlOffset : 0;
 
-    // Compute the y-axis offset between the bottom left and bottom right points.
-    // If the <select>/<input> is transformed, they are not the same.
+    // Compute the y-axis offset between the bottom left and bottom right
+    // points. If the <select>/<input> is transformed, they are not the same.
     int verticalOffset = - m_controlPosition.p4().y() + m_controlPosition.p3().y();
     int verticalForRTLOffset = isRTL ? verticalOffset : 0;
 
     // Assume m_listBox size is already calculated.
-    IntSize targetSize(m_listBox->width() + kBorderSize * 2,
-                       m_listBox->height() + kBorderSize * 2);
+    IntSize targetSize(m_listBox->width() + borderSize * 2, m_listBox->height() + borderSize * 2);
 
     IntRect widgetRectInScreen;
     if (ChromeClient* client = chromeClient()) {
         // If the popup would extend past the bottom of the screen, open upwards
         // instead.
         FloatRect screen = screenAvailableRect(m_frameView.get());
         // Use popupInitialCoordinate.x() + rightOffset because RTL position
         // needs to be considered.
         widgetRectInScreen = client->rootViewToScreen(IntRect(popupInitialCoordinate.x() + rightOffset, popupInitialCoordinate.y() + verticalForRTLOffset, targetSize.width(), targetSize.height()));
 
-        // If we have multiple screens and the browser rect is in one screen, we have
-        // to clip the window width to the screen width.
+        // If we have multiple screens and the browser rect is in one screen, we
+        // have to clip the window width to the screen width.
         // When clipping, we also need to set a maximum width for the list box.
         FloatRect windowRect = client->windowRect();
 
         bool needToResizeView = false;
         widgetRectInScreen = layoutAndCalculateWidgetRectInternal(widgetRectInScreen, targetControlHeight, windowRect, screen, isRTL, rtlOffset, verticalOffset, transformOffset, m_listBox.get(), needToResizeView);
         if (needToResizeView)
             fitToListBox();
     }
 
     return widgetRectInScreen;
@@ skipping 31 matching lines @@
 {
     if (!m_popupOpen)
         return;
     m_popupOpen = false;
     chromeClient()->popupClosed(this);
 }
 
 void PopupContainer::fitToListBox()
 {
     // Place the listbox within our border.
-    m_listBox->move(kBorderSize, kBorderSize);
+    m_listBox->move(borderSize, borderSize);
 
     // Size ourselves to contain listbox + border.
-    resize(m_listBox->width() + kBorderSize * 2, m_listBox->height() + kBorderSize * 2);
+    resize(m_listBox->width() + borderSize * 2, m_listBox->height() + borderSize * 2);
     invalidate();
 }
 
 bool PopupContainer::handleMouseDownEvent(const PlatformMouseEvent& event)
 {
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     return m_listBox->handleMouseDownEvent(
         constructRelativeMouseEvent(event, this, m_listBox.get()));
 }
 
@@ skipping 17 matching lines @@
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     return m_listBox->handleWheelEvent(
         constructRelativeWheelEvent(event, this, m_listBox.get()));
 }
 
 bool PopupContainer::handleTouchEvent(const PlatformTouchEvent&)
 {
     return false;
 }
 
-// FIXME: Refactor this code to share functionality with EventHandler::handleGestureEvent.
+// FIXME: Refactor this code to share functionality with
+// EventHandler::handleGestureEvent.
 bool PopupContainer::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 {
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureTap: {
         PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(), NoButton, PlatformEvent::MouseMoved, /* clickCount */ 1, gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), gestureEvent.timestamp());
         PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, /* clickCount */ 1, gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), gestureEvent.timestamp());
         PlatformMouseEvent fakeMouseUp(gestureEvent.position(), gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseReleased, /* clickCount */ 1, gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), gestureEvent.timestamp());
         // handleMouseMoveEvent(fakeMouseMove);
         handleMouseDownEvent(fakeMouseDown);
         handleMouseReleaseEvent(fakeMouseUp);
@@ skipping 21 matching lines @@
     return m_listBox->handleKeyEvent(event);
 }
 
 void PopupContainer::hide()
 {
     m_listBox->abandon();
 }
 
 void PopupContainer::paint(GraphicsContext* gc, const IntRect& rect)
 {
-    // adjust coords for scrolled frame
+    // Adjust coords for scrolled frame.
     IntRect r = intersection(rect, frameRect());
     int tx = x();
     int ty = y();
 
     r.move(-tx, -ty);
 
     gc->translate(static_cast<float>(tx), static_cast<float>(ty));
     m_listBox->paint(gc, r);
     gc->translate(-static_cast<float>(tx), -static_cast<float>(ty));
 
     paintBorder(gc, rect);
 }
 
 void PopupContainer::paintBorder(GraphicsContext* gc, const IntRect& rect)
 {
     // FIXME: Where do we get the border color from?
     Color borderColor(127, 157, 185);
 
     gc->setStrokeStyle(NoStroke);
     gc->setFillColor(borderColor, ColorSpaceDeviceRGB);
 
     int tx = x();
     int ty = y();
 
     // top, left, bottom, right
-    gc->drawRect(IntRect(tx, ty, width(), kBorderSize));
-    gc->drawRect(IntRect(tx, ty, kBorderSize, height()));
-    gc->drawRect(IntRect(tx, ty + height() - kBorderSize, width(), kBorderSize));
-    gc->drawRect(IntRect(tx + width() - kBorderSize, ty, kBorderSize, height()));
+    gc->drawRect(IntRect(tx, ty, width(), borderSize));
+    gc->drawRect(IntRect(tx, ty, borderSize, height()));
+    gc->drawRect(IntRect(tx, ty + height() - borderSize, width(), borderSize));
+    gc->drawRect(IntRect(tx + width() - borderSize, ty, borderSize, height()));
 }
 
 bool PopupContainer::isInterestedInEventForKey(int keyCode)
 {
     return m_listBox->isInterestedInEventForKey(keyCode);
 }
 
 ChromeClient* PopupContainer::chromeClient()
 {
     return m_frameView->frame()->page()->chrome()->client();
 }
 
 void PopupContainer::showInRect(const FloatQuad& controlPosition, const IntSize& controlSize, FrameView* v, int index)
 {
-    // The controlSize is the size of the select box. It's usually larger than we need.
-    // subtract border size so that usually the container will be displayed
-    // exactly the same width as the select box.
-    listBox()->setBaseWidth(max(controlSize.width() - kBorderSize * 2, 0));
+    // The controlSize is the size of the select box. It's usually larger than
+    // we need. Subtract border size so that usually the container will be
+    // displayed exactly the same width as the select box.
+    listBox()->setBaseWidth(max(controlSize.width() - borderSize * 2, 0));
 
     listBox()->updateFromElement();
 
     // We set the selected item in updateFromElement(), and disregard the
     // index passed into this function (same as Webkit's PopupMenuWin.cpp)
     // FIXME: make sure this is correct, and add an assertion.
     // ASSERT(popupWindow(popup)->listBox()->selectedIndex() == index);
 
     // Save and convert the controlPosition to main window coords.
     m_controlPosition = controlPosition;
     IntPoint delta = v->contentsToWindow(IntPoint());
     m_controlPosition.move(delta.x(), delta.y());
     m_controlSize = controlSize;
 
-    // Position at (0, 0) since the frameRect().location() is relative to the parent WebWidget.
+    // Position at (0, 0) since the frameRect().location() is relative to the
+    // parent WebWidget.
     setFrameRect(IntRect(IntPoint(), controlSize));
     showPopup(v);
 }
 
 IntRect PopupContainer::refresh(const IntRect& targetControlRect)
 {
-    listBox()->setBaseWidth(max(m_controlSize.width() - kBorderSize * 2, 0));
+    listBox()->setBaseWidth(max(m_controlSize.width() - borderSize * 2, 0));
     listBox()->updateFromElement();
 
     IntPoint locationInWindow = m_frameView->contentsToWindow(targetControlRect.location());
 
     // Move it below the select widget.
     locationInWindow.move(0, targetControlRect.height());
 
     IntRect widgetRectInScreen = layoutAndCalculateWidgetRect(targetControlRect.height(), IntSize(), locationInWindow);
 
-    // Reset the size (which can be set to the PopupListBox size in layoutAndGetRTLOffset(), exceeding the available widget rectangle.)
+    // Reset the size (which can be set to the PopupListBox size in
+    // layoutAndGetRTLOffset(), exceeding the available widget rectangle.)
     if (size() != widgetRectInScreen.size())
         resize(widgetRectInScreen.size());
 
     invalidate();
 
     return widgetRectInScreen;
 }
 
 inline bool PopupContainer::isRTL() const
 {
@@ skipping 21 matching lines @@
 }
 
 const WTF::Vector<PopupItem*>& PopupContainer:: popupData() const
 {
     return m_listBox->items();
 }
 
 String PopupContainer::getSelectedItemToolTip()
 {
     // We cannot use m_popupClient->selectedIndex() to choose tooltip message,
-    // because the selectedIndex() might return final selected index, not hovering selection.
+    // because the selectedIndex() might return final selected index, not
+    // hovering selection.
     return listBox()->m_popupClient->itemToolTip(listBox()->m_selectedIndex);
 }
 
 } // namespace WebCore