Removing "using" declarations that import names in the C++ Standard library.

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 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 143 matching lines @@
 
 #if USE(DEFAULT_RENDER_THEME)
 #include "core/rendering/RenderThemeChromiumDefault.h"
 #endif
 
 // Get rid of WTF's pow define so we can use std::pow.
 #undef pow
 #include <cmath> // for std::pow
 
 using namespace WebCore;
-using namespace std;
 
 // The following constants control parameters for automated scaling of webpages
 // (such as due to a double tap gesture or find in page etc.). These are
 // experimentally determined.
 static const int touchPointPadding = 32;
 static const int nonUserInitiatedPointPadding = 11;
 static const float minScaleDifference = 0.01f;
 static const float doubleTapZoomContentDefaultMargin = 5;
 static const float doubleTapZoomContentMinimumMargin = 2;
 static const double doubleTapZoomAnimationDurationInSeconds = 0.25;
@@ skipping 479 matching lines @@
     // complicated set of cases handled below.
     switch (event.type) {
     case WebInputEvent::GestureShowPress:
         // Queue a highlight animation, then hand off to regular handler.
         if (settingsImpl()->gestureTapHighlightEnabled())
             enableTapHighlightAtPoint(platformEvent);
         break;
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTap:
     case WebInputEvent::GestureLongPress:
-        for (size_t i = 0; i < m_linkHighlights.size(); ++i)
+        for (std::size_t i = 0; i < m_linkHighlights.size(); ++i)
             m_linkHighlights[i]->startHighlightAnimationIfNeeded();
         break;
     default:
         break;
     }
 
     switch (event.type) {
     case WebInputEvent::GestureTap: {
         m_client->cancelScheduledContentIntents();
         if (detectContentOnTouch(platformEvent.position())) {
@@ skipping 18 matching lines @@
             scaledEvent.data.tap.height = event.data.tap.height / pageScaleFactor();
             IntRect boundingBox(scaledEvent.x - scaledEvent.data.tap.width / 2, scaledEvent.y - scaledEvent.data.tap.height / 2, scaledEvent.data.tap.width, scaledEvent.data.tap.height);
             Vector<IntRect> goodTargets;
             WillBeHeapVector<RawPtrWillBeMember<Node> > highlightNodes;
             findGoodTouchTargets(boundingBox, mainFrameImpl()->frame(), goodTargets, highlightNodes);
             // FIXME: replace touch adjustment code when numberOfGoodTargets == 1?
             // Single candidate case is currently handled by: https://bugs.webkit.org/show_bug.cgi?id=85101
             if (goodTargets.size() >= 2 && m_client && m_client->didTapMultipleTargets(scaledEvent, goodTargets)) {
                 if (settingsImpl()->gestureTapHighlightEnabled())
                     enableTapHighlights(highlightNodes);
-                for (size_t i = 0; i < m_linkHighlights.size(); ++i)
+                for (std::size_t i = 0; i < m_linkHighlights.size(); ++i)
                     m_linkHighlights[i]->startHighlightAnimationIfNeeded();
                 eventSwallowed = true;
                 eventCancelled = true;
                 break;
             }
         }
 
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
 
         if (m_selectPopup && m_selectPopup == selectPopup) {
@@ skipping 344 matching lines @@
         maxSize = mainFrame()->contentsSize();
     IntSize scrollOffset;
     if (mainFrame())
         scrollOffset = mainFrame()->scrollOffset();
     int leftMargin = targetMargin;
     int rightMargin = targetMargin;
 
     const int absoluteSourceX = source.x + scrollOffset.width();
     if (leftMargin > absoluteSourceX) {
         leftMargin = absoluteSourceX;
-        rightMargin = max(leftMargin, minimumMargin);
+        rightMargin = std::max(leftMargin, minimumMargin);
     }
 
     const int maximumRightMargin = maxSize.width - (source.width + absoluteSourceX);
     if (rightMargin > maximumRightMargin) {
         rightMargin = maximumRightMargin;
-        leftMargin = min(leftMargin, max(rightMargin, minimumMargin));
+        leftMargin = std::min(leftMargin, std::max(rightMargin, minimumMargin));
     }
 
     const int newWidth = source.width + leftMargin + rightMargin;
     const int newX = source.x - leftMargin;
 
     ASSERT(newWidth >= 0);
     ASSERT(scrollOffset.width() + newX + newWidth <= maxSize.width);
 
     return WebRect(newX, source.y, newWidth, source.height);
 }
@@ skipping 24 matching lines @@
         // need to express them in post-scale size. To do that we'd need to know
         // the scale we're scaling to, but that depends on the margins. Instead
         // we express them as a fraction of the target rectangle: this will be
         // correct if we end up fully zooming to it, and won't matter if we
         // don't.
         rect = widenRectWithinPageBounds(rect,
                 static_cast<int>(defaultMargin * rect.width / m_size.width),
                 static_cast<int>(minimumMargin * rect.width / m_size.width));
         // Fit block to screen, respecting limits.
         scale = static_cast<float>(m_size.width) / rect.width;
-        scale = min(scale, legibleScale());
+        scale = std::min(scale, legibleScale());
         if (pageScaleFactor() < defaultScaleWhenAlreadyLegible)
-            scale = max(scale, defaultScaleWhenAlreadyLegible);
+            scale = std::max(scale, defaultScaleWhenAlreadyLegible);
         scale = clampPageScaleFactorToLimits(scale);
     }
 
     // FIXME: If this is being called for auto zoom during find in page,
     // then if the user manually zooms in it'd be nice to preserve the
     // relative increase in zoom they caused (if they zoom out then it's ok
     // to zoom them back in again). This isn't compatible with our current
     // double-tap zoom strategy (fitting the containing block to the screen)
     // though.
 
@@ skipping 82 matching lines @@
     if (highlightNodes.isEmpty())
         return;
 
     // Always clear any existing highlight when this is invoked, even if we
     // don't get a new target to highlight.
     m_linkHighlights.clear();
 
     // LinkHighlight reads out layout and compositing state, so we need to make sure that's all up to date.
     layout();
 
-    for (size_t i = 0; i < highlightNodes.size(); ++i) {
+    for (std::size_t i = 0; i < highlightNodes.size(); ++i) {
         Node* node = highlightNodes[i];
 
         if (!node || !node->renderer())
             continue;
 
         Color highlightColor = node->renderer()->style()->tapHighlightColor();
         // Safari documentation for -webkit-tap-highlight-color says if the specified color has 0 alpha,
         // then tap highlighting is disabled.
         // http://developer.apple.com/library/safari/#documentation/appleapplications/reference/safaricssref/articles/standardcssproperties.html
         if (!highlightColor.alpha())
@@ skipping 475 matching lines @@
         m_client->scheduleAnimation();
     }
 }
 
 void WebViewImpl::layout()
 {
     TRACE_EVENT0("webkit", "WebViewImpl::layout");
     PageWidgetDelegate::layout(m_page.get());
     updateLayerTreeBackgroundColor();
 
-    for (size_t i = 0; i < m_linkHighlights.size(); ++i)
+    for (std::size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->updateGeometry();
 }
 
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
     // This should only be used when compositing is not being used for this
     // WebView, and it is painting into the recording of its parent.
     ASSERT(!isAcceleratedCompositingActive());
 
     double paintStart = currentTime();
@@ skipping 328 matching lines @@
     LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
         return plugin->confirmComposition(text, selectionBehavior);
 
     return focused->inputMethodController().confirmCompositionOrInsertText(text, selectionBehavior == KeepSelection ? InputMethodController::KeepSelection : InputMethodController::DoNotKeepSelection);
 }
 
-bool WebViewImpl::compositionRange(size_t* location, size_t* length)
+bool WebViewImpl::compositionRange(std::size_t* location, std::size_t* length)
 {
     LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     RefPtrWillBeRawPtr<Range> range = focused->inputMethodController().compositionRange();
     if (!range)
         return false;
 
     Element* editable = focused->selection().rootEditableElementOrDocumentElement();
@@ skipping 248 matching lines @@
     return false;
 }
 
 WebVector<WebCompositionUnderline> WebViewImpl::compositionUnderlines() const
 {
     const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return WebVector<WebCompositionUnderline>();
     const Vector<CompositionUnderline>& underlines = focused->inputMethodController().customCompositionUnderlines();
     WebVector<WebCompositionUnderline> results(underlines.size());
-    for (size_t index = 0; index < underlines.size(); ++index) {
+    for (std::size_t index = 0; index < underlines.size(); ++index) {
         CompositionUnderline underline = underlines[index];
         results[index] = WebCompositionUnderline(underline.startOffset, underline.endOffset, static_cast<WebColor>(underline.color.rgb()), underline.thick);
     }
     return results;
 }
 
 WebColor WebViewImpl::backgroundColor() const
 {
     if (isTransparent())
         return Color::transparent;
     if (!m_page)
         return m_baseBackgroundColor;
     if (!m_page->mainFrame())
         return m_baseBackgroundColor;
     FrameView* view = m_page->mainFrame()->view();
     return view->documentBackgroundColor().rgb();
 }
 
-bool WebViewImpl::caretOrSelectionRange(size_t* location, size_t* length)
+bool WebViewImpl::caretOrSelectionRange(std::size_t* location, std::size_t* length)
 {
     const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return false;
 
     PlainTextRange selectionOffsets = focused->inputMethodController().getSelectionOffsets();
     if (selectionOffsets.isNull())
         return false;
 
     *location = selectionOffsets.start();
@@ skipping 231 matching lines @@
 
     int viewWidth = m_size.width / newScale;
     int viewHeight = m_size.height / newScale;
 
     if (textboxRectInDocumentCoordinates.width() <= viewWidth) {
         // Field is narrower than screen. Try to leave padding on left so field's
         // label is visible, but it's more important to ensure entire field is
         // onscreen.
         int idealLeftPadding = viewWidth * leftBoxRatio;
         int maxLeftPaddingKeepingBoxOnscreen = viewWidth - textboxRectInDocumentCoordinates.width();
-        newScroll.setX(textboxRectInDocumentCoordinates.x() - min<int>(idealLeftPadding, maxLeftPaddingKeepingBoxOnscreen));
+        newScroll.setX(textboxRectInDocumentCoordinates.x() - std::min<int>(idealLeftPadding, maxLeftPaddingKeepingBoxOnscreen));
     } else {
         // Field is wider than screen. Try to left-align field, unless caret would
         // be offscreen, in which case right-align the caret.
         newScroll.setX(max<int>(textboxRectInDocumentCoordinates.x(), caretInDocumentCoordinates.x() + caretInDocumentCoordinates.width() + caretPadding - viewWidth));
     }
     if (textboxRectInDocumentCoordinates.height() <= viewHeight) {
         // Field is shorter than screen. Vertically center it.
         newScroll.setY(textboxRectInDocumentCoordinates.y() - (viewHeight - textboxRectInDocumentCoordinates.height()) / 2);
     } else {
         // Field is taller than screen. Try to top align field, unless caret would
@@ skipping 68 matching lines @@
     frame->setTextZoomFactor(textZoomFactor);
 
     return textZoomFactor;
 }
 
 void WebViewImpl::fullFramePluginZoomLevelChanged(double zoomLevel)
 {
     if (zoomLevel == m_zoomLevel)
         return;
 
-    m_zoomLevel = max(min(zoomLevel, m_maximumZoomLevel), m_minimumZoomLevel);
+    m_zoomLevel = std::max(std::min(zoomLevel, m_maximumZoomLevel), m_minimumZoomLevel);
     m_client->zoomLevelChanged();
 }
 
 double WebView::zoomLevelToZoomFactor(double zoomLevel)
 {
     return pow(textSizeMultiplierRatio, zoomLevel);
 }
 
 double WebView::zoomFactorToZoomLevel(double factor)
 {
@@ skipping 564 matching lines @@
     UserGestureIndicator gesture(DefinitelyProcessingNewUserGesture);
     m_page->dragController().performDrag(&dragData);
 
     m_dragOperation = WebDragOperationNone;
     m_currentDragData = nullptr;
 }
 
 void WebViewImpl::spellingMarkers(WebVector<uint32_t>* markers)
 {
     Vector<uint32_t> result;
-    for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
-        if (!frame->isLocalFrame())
-            continue;
-        const WillBeHeapVector<DocumentMarker*>& documentMarkers = toLocalFrame(frame)->document()->markers().markers();
-        for (size_t i = 0; i < documentMarkers.size(); ++i)
+    for (LocalFrame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
+        const WillBeHeapVector<DocumentMarker*>& documentMarkers = frame->document()->markers().markers();
+        for (std::size_t i = 0; i < documentMarkers.size(); ++i)
             result.append(documentMarkers[i]->hash());
     }
     markers->assign(result);
 }
 
 WebDragOperation WebViewImpl::dragTargetDragEnterOrOver(const WebPoint& clientPoint, const WebPoint& screenPoint, DragAction dragAction, int keyModifiers)
 {
     ASSERT(m_currentDragData);
 
     m_currentDragData->setModifierKeyState(webInputEventKeyStateToPlatformEventKeyState(keyModifiers));
@@ skipping 246 matching lines @@
                                      unsigned inactiveForegroundColor) {
 #if USE(DEFAULT_RENDER_THEME)
     RenderThemeChromiumDefault::setSelectionColors(activeBackgroundColor, activeForegroundColor, inactiveBackgroundColor, inactiveForegroundColor);
     RenderTheme::theme().platformColorsDidChange();
 #endif
 }
 
 void WebView::injectStyleSheet(const WebString& sourceCode, const WebVector<WebString>& patternsIn, WebView::StyleInjectionTarget injectIn)
 {
     Vector<String> patterns;
-    for (size_t i = 0; i < patternsIn.size(); ++i)
+    for (std::size_t i = 0; i < patternsIn.size(); ++i)
         patterns.append(patternsIn[i]);
 
     InjectedStyleSheets::instance().add(sourceCode, patterns, static_cast<WebCore::StyleInjectionTarget>(injectIn));
 }
 
 void WebView::removeInjectedStyleSheets()
 {
     InjectedStyleSheets::instance().removeAll();
 }
 
@@ skipping 539 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink