General code cleanup of ChromeClient-related classes.

Source/web/ChromeClientImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  *
  * 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.
@@ skipping 127 matching lines @@
 
 void ChromeClientImpl::setWindowRect(const IntRect& r)
 {
     if (m_webView->client())
         m_webView->client()->setWindowRect(r);
 }
 
 IntRect ChromeClientImpl::windowRect()
 {
     WebRect rect;
-    if (m_webView->client())
+    if (m_webView->client()) {
         rect = m_webView->client()->rootWindowRect();
-    else {
+    } else {
         // These numbers will be fairly wrong. The window's x/y coordinates will
         // be the top left corner of the screen and the size will be the content
         // size instead of the window size.
         rect.width = m_webView->size().width;
         rect.height = m_webView->size().height;
     }
     return IntRect(rect);
 }
 
 IntRect ChromeClientImpl::pageRect()
@@ skipping 133 matching lines @@
 
     WebViewImpl* newView = toWebViewImpl(
         m_webView->client()->createView(WebLocalFrameImpl::fromFrame(frame), WrappedResourceRequest(r.resourceRequest()), features, r.frameName(), policy, shouldSendReferrer == NeverSendReferrer));
     if (!newView)
         return nullptr;
     return newView->page();
 }
 
 void ChromeClientImpl::show(NavigationPolicy navigationPolicy)
 {
-    if (!m_webView->client())
-        return;
-
-    WebNavigationPolicy policy = effectiveNavigationPolicy(navigationPolicy, m_windowFeatures);
-    m_webView->client()->show(policy);
+    if (m_webView->client())
+        m_webView->client()->show(effectiveNavigationPolicy(navigationPolicy, m_windowFeatures));
 }
 
 void ChromeClientImpl::setToolbarsVisible(bool value)
 {
     m_windowFeatures.toolBarVisible = value;
 }
 
 bool ChromeClientImpl::toolbarsVisible()
 {
     return m_windowFeatures.toolBarVisible;
 }
 
 void ChromeClientImpl::setStatusbarVisible(bool value)
 {
     m_windowFeatures.statusBarVisible = value;
 }
 
 bool ChromeClientImpl::statusbarVisible()
 {
     return m_windowFeatures.statusBarVisible;
 }
 
 void ChromeClientImpl::setScrollbarsVisible(bool value)
 {
     m_windowFeatures.scrollbarsVisible = value;
-    WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
-    if (webFrame)
+    if (WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame()))
         webFrame->setCanHaveScrollbars(value);
 }
 
 bool ChromeClientImpl::scrollbarsVisible()
 {
     return m_windowFeatures.scrollbarsVisible;
 }
 
 void ChromeClientImpl::setMenubarVisible(bool value)
 {
@@ skipping 31 matching lines @@
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
 {
     return !!m_webView->client();
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanelInternal(LocalFrame* frame, const String& message)
 {
     notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
 
-    bool isReload = false;
     WebDataSource* ds = webframe->provisionalDataSource();
-    if (ds)
-        isReload = (ds->navigationType() == WebNavigationTypeReload);
+    bool isReload = ds && (ds->navigationType() == WebNavigationTypeReload);
 
     if (webframe->client())
         return webframe->client()->runModalBeforeUnloadDialog(isReload, message);
     return false;
 }
 
 void ChromeClientImpl::closeWindowSoon()
 {
     // Make sure this Page can no longer be found by JS.
     Page::ordinaryPages().remove(m_webView->page());
@@ skipping 33 matching lines @@
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptPromptInternal(LocalFrame* frame, const String& message, const String& defaultValue, String& result)
 {
     notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         WebString actualValue;
-        bool ok = webframe->client()->runModalPromptDialog(
-            message,
-            defaultValue,
-            &actualValue);
+        bool ok = webframe->client()->runModalPromptDialog(message, defaultValue, &actualValue);
         if (ok)
             result = actualValue;
         return ok;
     }
     return false;
 }
 
 void ChromeClientImpl::setStatusbarText(const String& message)
 {
     if (m_webView->client())
         m_webView->client()->setStatusText(message);
 }
 
 bool ChromeClientImpl::tabsToLinks()
 {
     return m_webView->tabsToLinks();
 }
 
 IntRect ChromeClientImpl::windowResizerRect() const
 {
-    IntRect result;
     if (m_webView->client())
-        result = m_webView->client()->windowResizerRect();
-    return result;
+        return m_webView->client()->windowResizerRect();
+    return IntRect();
 }
 
 void ChromeClientImpl::invalidateRect(const IntRect& updateRect)
 {
-    if (updateRect.isEmpty())
-        return;
-    m_webView->invalidateRect(updateRect);
+    if (!updateRect.isEmpty())
+        m_webView->invalidateRect(updateRect);
 }
 
 void ChromeClientImpl::scheduleAnimation()
 {
     m_webView->scheduleAnimation();
 }
 
 void ChromeClientImpl::scheduleAnimationForFrame(LocalFrame* localRoot)
 {
     ASSERT(WebLocalFrameImpl::fromFrame(localRoot));
@@ skipping 121 matching lines @@
     WebFileChooserParams params;
     params.multiSelect = fileChooser->settings().allowsMultipleFiles;
     params.directory = fileChooser->settings().allowsDirectoryUpload;
     params.acceptTypes = fileChooser->settings().acceptTypes();
     params.selectedFiles = fileChooser->settings().selectedFiles;
     if (params.selectedFiles.size() > 0)
         params.initialValue = params.selectedFiles[0];
     params.useMediaCapture = fileChooser->settings().useMediaCapture;
     params.needLocalPath = fileChooser->settings().allowsDirectoryUpload;
 
-    WebFileChooserCompletionImpl* chooserCompletion =
-        new WebFileChooserCompletionImpl(fileChooser);
-
+    WebFileChooserCompletionImpl* chooserCompletion = new WebFileChooserCompletionImpl(fileChooser);
     if (client->runFileChooser(params, chooserCompletion))
         return;
-
     // Choosing failed, so do callback with an empty list.
     chooserCompletion->didChooseFile(WebVector<WebString>());
 }
 
 void ChromeClientImpl::enumerateChosenDirectory(FileChooser* fileChooser)
 {
     WebViewClient* client = m_webView->client();
     if (!client)
         return;
 
-    WebFileChooserCompletionImpl* chooserCompletion =
-        new WebFileChooserCompletionImpl(fileChooser);
+    WebFileChooserCompletionImpl* chooserCompletion = new WebFileChooserCompletionImpl(fileChooser);
 
-    ASSERT(fileChooser && fileChooser->settings().selectedFiles.size());
+    ASSERT(fileChooser);
+    ASSERT(fileChooser->settings().selectedFiles.size());
 
     // If the enumeration can't happen, call the callback with an empty list.
     if (!client->enumerateChosenDirectory(fileChooser->settings().selectedFiles[0], chooserCompletion))
         chooserCompletion->didChooseFile(WebVector<WebString>());
 }
 
 void ChromeClientImpl::setCursorInternal(const Cursor& cursor)
 {
     setCursor(WebCursorInfo(cursor));
 }
@@ skipping 35 matching lines @@
     return m_webView->client()->acceptLanguages();
 }
 
 GraphicsLayerFactory* ChromeClientImpl::graphicsLayerFactory() const
 {
     return m_webView->graphicsLayerFactory();
 }
 
 void ChromeClientImpl::attachRootGraphicsLayer(GraphicsLayer* rootLayer, LocalFrame* localRoot)
 {
-    // FIXME: For top-level frames we still use the WebView as a WebWidget. This special
-    // case will be removed when top-level frames get WebFrameWidgets.
+    // FIXME: For top-level frames we still use the WebView as a WebWidget. This
+    // special case will be removed when top-level frames get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->setRootGraphicsLayer(rootLayer);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
-        // FIXME: The following conditional is only needed for staging until the Chromium patch
-        // lands that instantiates a WebFrameWidget.
+        // FIXME: The following conditional is only needed for staging until the
+        // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->setRootGraphicsLayer(rootLayer);
             return;
         }
-        ASSERT(webFrame && webFrame->frameWidget());
+        ASSERT(webFrame);
+        ASSERT(webFrame->frameWidget());
         webFrame->frameWidget()->setRootGraphicsLayer(rootLayer);
     }
 }
 
 void ChromeClientImpl::attachCompositorAnimationTimeline(WebCompositorAnimationTimeline* compositorTimeline, LocalFrame* localRoot)
 {
-    // FIXME: For top-level frames we still use the WebView as a WebWidget. This special
-    // case will be removed when top-level frames get WebFrameWidgets.
+    // FIXME: For top-level frames we still use the WebView as a WebWidget. This
+    // special case will be removed when top-level frames get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->attachCompositorAnimationTimeline(compositorTimeline);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
-        // FIXME: The following conditional is only needed for staging until the Chromium patch
-        // lands that instantiates a WebFrameWidget.
+        // FIXME: The following conditional is only needed for staging until the
+        // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->attachCompositorAnimationTimeline(compositorTimeline);
             return;
         }
-        ASSERT(webFrame && webFrame->frameWidget());
+        ASSERT(webFrame);
+        ASSERT(webFrame->frameWidget());
         webFrame->frameWidget()->attachCompositorAnimationTimeline(compositorTimeline);
     }
 }
 
 void ChromeClientImpl::detachCompositorAnimationTimeline(WebCompositorAnimationTimeline* compositorTimeline, LocalFrame* localRoot)
 {
-    // FIXME: For top-level frames we still use the WebView as a WebWidget. This special
-    // case will be removed when top-level frames get WebFrameWidgets.
+    // FIXME: For top-level frames we still use the WebView as a WebWidget. This
+    // special case will be removed when top-level frames get WebFrameWidgets.
     if (localRoot->isMainFrame()) {
         m_webView->detachCompositorAnimationTimeline(compositorTimeline);
     } else {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(localRoot);
-        // FIXME: The following conditional is only needed for staging until the Chromium patch
-        // lands that instantiates a WebFrameWidget.
+        // FIXME: The following conditional is only needed for staging until the
+        // Chromium patch lands that instantiates a WebFrameWidget.
         if (!webFrame->frameWidget()) {
             m_webView->detachCompositorAnimationTimeline(compositorTimeline);
             return;
         }
-        ASSERT(webFrame && webFrame->frameWidget());
+        ASSERT(webFrame);
+        ASSERT(webFrame->frameWidget());
         webFrame->frameWidget()->detachCompositorAnimationTimeline(compositorTimeline);
     }
 }
 
 void ChromeClientImpl::enterFullScreenForElement(Element* element)
 {
     m_webView->enterFullScreenForElement(element);
 }
 
 void ChromeClientImpl::exitFullScreenForElement(Element* element)
@@ skipping 40 matching lines @@
 
 DOMWindow* ChromeClientImpl::pagePopupWindowForTesting() const
 {
     return m_webView->pagePopupWindow();
 }
 
 bool ChromeClientImpl::shouldRunModalDialogDuringPageDismissal(const DialogType& dialogType, const String& dialogMessage, Document::PageDismissalType dismissalType) const
 {
     const char* kDialogs[] = {"alert", "confirm", "prompt"};
     int dialog = static_cast<int>(dialogType);
-    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dialog && dialog < static_cast<int>(arraysize(kDialogs)));
+    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dialog);
+    ASSERT_WITH_SECURITY_IMPLICATION(dialog < static_cast<int>(arraysize(kDialogs)));
 
     const char* kDismissals[] = {"beforeunload", "pagehide", "unload"};
     int dismissal = static_cast<int>(dismissalType) - 1; // Exclude NoDismissal.
-    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dismissal && dismissal < static_cast<int>(arraysize(kDismissals)));
+    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dismissal);
+    ASSERT_WITH_SECURITY_IMPLICATION(dismissal < static_cast<int>(arraysize(kDismissals)));
 
     Platform::current()->histogramEnumeration("Renderer.ModalDialogsDuringPageDismissal", dismissal * arraysize(kDialogs) + dialog, arraysize(kDialogs) * arraysize(kDismissals));
 
     String message = String("Blocked ") + kDialogs[dialog] + "('" + dialogMessage + "') during " + kDismissals[dismissal] + ".";
     m_webView->mainFrame()->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelError, message));
 
     return false;
 }
 
 void ChromeClientImpl::needTouchEvents(bool needsTouchEvents)
 {
     m_webView->hasTouchEventHandlers(needsTouchEvents);
 }
 
 void ChromeClientImpl::setTouchAction(TouchAction touchAction)
 {
-    if (WebViewClient* client = m_webView->client()) {
-        WebTouchAction webTouchAction = static_cast<WebTouchAction>(touchAction);
-        client->setTouchAction(webTouchAction);
-    }
+    if (WebViewClient* client = m_webView->client())
+        client->setTouchAction(static_cast<WebTouchAction>(touchAction));
 }
 
 bool ChromeClientImpl::requestPointerLock()
 {
     return m_webView->requestPointerLock();
 }
 
 void ChromeClientImpl::requestPointerUnlock()
 {
     return m_webView->requestPointerUnlock();
 }
 
 void ChromeClientImpl::annotatedRegionsChanged()
 {
-    WebViewClient* client = m_webView->client();
-    if (client)
+    if (WebViewClient* client = m_webView->client())
         client->draggableRegionsChanged();
 }
 
 void ChromeClientImpl::didAssociateFormControls(const WillBeHeapVector<RefPtrWillBeMember<Element>>& elements, LocalFrame* frame)
 {
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->autofillClient())
         webframe->autofillClient()->didAssociateFormControls(elements);
 }
 
@@ skipping 90 matching lines @@
 void ChromeClientImpl::unregisterPopupOpeningObserver(PopupOpeningObserver* observer)
 {
     size_t index = m_popupOpeningObservers.find(observer);
     ASSERT(index != kNotFound);
     m_popupOpeningObservers.remove(index);
 }
 
 void ChromeClientImpl::notifyPopupOpeningObservers() const
 {
     const Vector<PopupOpeningObserver*> observers(m_popupOpeningObservers);
-    for (size_t i = 0; i < observers.size(); ++i)
-        observers[i]->willOpenPopup();
+    for (const auto& observer : observers)
+        observer->willOpenPopup();
 }
 
 } // namespace blink