Rename some functions of which names contain 'WebCore.'

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 301 matching lines @@
 {
     ASSERT(pageLoadDeferrerStack().size());
 
     delete pageLoadDeferrerStack().last();
     pageLoadDeferrerStack().removeLast();
 }
 
 void WebViewImpl::setMainFrame(WebFrame* frame)
 {
     if (frame->isWebLocalFrame())
-        toWebLocalFrameImpl(frame)->initializeWebCoreFrame(&page()->frameHost(), 0, nullAtom, nullAtom);
+        toWebLocalFrameImpl(frame)->initializeCoreFrame(&page()->frameHost(), 0, nullAtom, nullAtom);
     else
-        toWebRemoteFrameImpl(frame)->initializeWebCoreFrame(&page()->frameHost(), 0, nullAtom);
+        toWebRemoteFrameImpl(frame)->initializeCoreFrame(&page()->frameHost(), 0, nullAtom);
 }
 
 void WebViewImpl::setAutofillClient(WebAutofillClient* autofillClient)
 {
     m_autofillClient = autofillClient;
 }
 
 void WebViewImpl::setDevToolsAgentClient(WebDevToolsAgentClient* devToolsClient)
 {
     if (devToolsClient)
@@ skipping 535 matching lines @@
 
 void WebViewImpl::setShowScrollBottleneckRects(bool show)
 {
     if (m_layerTreeView)
         m_layerTreeView->setShowScrollBottleneckRects(show);
     m_showScrollBottleneckRects = show;
 }
 
 void WebViewImpl::getSelectionRootBounds(WebRect& bounds) const
 {
-    const Frame* frame = focusedWebCoreFrame();
+    const Frame* frame = focusedCoreFrame();
     if (!frame || !frame->isLocalFrame())
         return;
 
     Element* root = toLocalFrame(frame)->selection().rootEditableElementOrDocumentElement();
     if (!root)
         return;
 
     // If the selection is inside a form control, the root will be a <div> that
     // behaves as the editor but we want to return the actual element's bounds.
     // In practice, that means <textarea> and <input> controls that behave like
@@ skipping 45 matching lines @@
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup) {
         m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
         // We need to ignore the next Char event after this otherwise pressing
         // enter when selecting an item in the popup will go to the page.
         if (WebInputEvent::RawKeyDown == event.type)
             m_suppressNextKeypressEvent = true;
         return true;
     }
 
-    RefPtr<Frame> focusedFrame = focusedWebCoreFrame();
+    RefPtr<Frame> focusedFrame = focusedCoreFrame();
     if (focusedFrame && focusedFrame->isRemoteFrameTemporary()) {
         WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(toLocalFrameTemporary(focusedFrame.get()));
         webFrame->client()->forwardInputEvent(&event);
         return true;
     }
 
     if (!focusedFrame || !focusedFrame->isLocalFrame())
         return false;
 
     RefPtr<LocalFrame> frame = toLocalFrame(focusedFrame.get());
@@ skipping 42 matching lines @@
     bool suppress = m_suppressNextKeypressEvent;
     m_suppressNextKeypressEvent = false;
 
     // If there is a select popup, it should be the one processing the event,
     // not the page.
     if (m_selectPopup)
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup)
         return m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
 
-    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* frame = toLocalFrame(focusedCoreFrame());
     if (!frame)
         return suppress;
 
     EventHandler& handler = frame->eventHandler();
 
     PlatformKeyboardEventBuilder evt(event);
     if (!evt.isCharacterKey())
         return true;
 
     // Accesskeys are triggered by char events and can't be suppressed.
@@ skipping 356 matching lines @@
     if (!page()->mainFrame()->isLocalFrame())
         return;
     m_contextMenuAllowed = true;
     page()->contextMenuController().clearContextMenu();
     page()->contextMenuController().showContextMenuAtPoint(page()->deprecatedLocalMainFrame(), x, y, menuProvider);
     m_contextMenuAllowed = false;
 }
 
 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)
 {
-    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* frame = toLocalFrame(focusedCoreFrame());
     if (!frame)
         return false;
 
     switch (event.type) {
     case WebInputEvent::Char:
         if (event.windowsKeyCode == VKEY_SPACE) {
             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
             return scrollViewWithKeyboard(keyCode, event.modifiers);
         }
         break;
@@ skipping 38 matching lines @@
     if (modifiers & WebMouseEvent::ControlKey) {
       if (keyCode == VKEY_UP)
         keyCode = VKEY_PRIOR;
       else if (keyCode == VKEY_DOWN)
         keyCode = VKEY_NEXT;
     }
 #endif
     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))
         return false;
 
-    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
-    if (!frame)
-        return false;
-    return frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity);
+    if (LocalFrame* frame = toLocalFrame(focusedCoreFrame()))
+        return frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity);
+    return false;
 }
 
 bool WebViewImpl::mapKeyCodeForScroll(
     int keyCode,
     ScrollDirection* scrollDirection,
     ScrollGranularity* scrollGranularity)
 {
     switch (keyCode) {
     case VKEY_LEFT:
         *scrollDirection = ScrollLeft;
@@ skipping 83 matching lines @@
 {
     ASSERT(popup);
     WebPagePopupImpl* popupImpl = toWebPagePopupImpl(popup);
     ASSERT(m_pagePopup.get() == popupImpl);
     if (m_pagePopup.get() != popupImpl)
         return;
     m_pagePopup->closePopup();
     m_pagePopup = nullptr;
 }
 
-Frame* WebViewImpl::focusedWebCoreFrame() const
+Frame* WebViewImpl::focusedCoreFrame() const
 {
     return m_page ? m_page->focusController().focusedOrMainFrame() : 0;
 }
 
 WebViewImpl* WebViewImpl::fromPage(Page* page)
 {
     if (!page)
         return 0;
     return static_cast<WebViewImpl*>(page->chrome().client().webView());
 }
@@ skipping 494 matching lines @@
         }
     }
 }
 
 bool WebViewImpl::setComposition(
     const WebString& text,
     const WebVector<WebCompositionUnderline>& underlines,
     int selectionStart,
     int selectionEnd)
 {
-    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
         return plugin->setComposition(text, underlines, selectionStart, selectionEnd);
 
     // The input focus has been moved to another WebWidget object.
     // We should use this |editor| object only to complete the ongoing
     // composition.
     InputMethodController& inputMethodController = focused->inputMethodController();
@@ skipping 45 matching lines @@
     return confirmComposition(WebString(), selectionBehavior);
 }
 
 bool WebViewImpl::confirmComposition(const WebString& text)
 {
     return confirmComposition(text, DoNotKeepSelection);
 }
 
 bool WebViewImpl::confirmComposition(const WebString& text, ConfirmCompositionBehavior selectionBehavior)
 {
-    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     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)
 {
-    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     RefPtrWillBeRawPtr<Range> range = focused->inputMethodController().compositionRange();
     if (!range)
         return false;
 
     Element* editable = focused->selection().rootEditableElementOrDocumentElement();
     ASSERT(editable);
     PlainTextRange plainTextRange(PlainTextRange::create(*editable, *range.get()));
     if (plainTextRange.isNull())
         return false;
     *location = plainTextRange.start();
     *length = plainTextRange.length();
     return true;
 }
 
 WebTextInputInfo WebViewImpl::textInputInfo()
 {
     WebTextInputInfo info;
 
-    Frame* focusedFrame = focusedWebCoreFrame();
+    Frame* focusedFrame = focusedCoreFrame();
     if (!focusedFrame->isLocalFrame())
         return info;
 
     LocalFrame* focused = toLocalFrame(focusedFrame);
     if (!focused)
         return info;
 
     FrameSelection& selection = focused->selection();
     Element* element = selection.selection().rootEditableElement();
     if (!element)
@@ skipping 141 matching lines @@
     if (isHTMLTextAreaElement(*element)) {
         const HTMLTextAreaElement& textarea = toHTMLTextAreaElement(*element);
         return textarea.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
     }
 
     return WebString();
 }
 
 bool WebViewImpl::selectionBounds(WebRect& anchor, WebRect& focus) const
 {
-    const Frame* frame = focusedWebCoreFrame();
+    const Frame* frame = focusedCoreFrame();
     if (!frame || !frame->isLocalFrame())
         return false;
 
     const LocalFrame* localFrame = toLocalFrame(frame);
     if (!localFrame)
         return false;
     FrameSelection& selection = localFrame->selection();
 
     if (selection.isCaret()) {
         anchor = focus = selection.absoluteCaretBounds();
@@ skipping 38 matching lines @@
     if (!selection.selection().isBaseFirst())
         std::swap(anchor, focus);
     return true;
 }
 
 InputMethodContext* WebViewImpl::inputMethodContext()
 {
     if (!m_imeAcceptEvents)
         return 0;
 
-    LocalFrame* focusedFrame = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* focusedFrame = toLocalFrame(focusedCoreFrame());
     if (!focusedFrame)
         return 0;
 
     Element* target = focusedFrame->document()->focusedElement();
     if (target && target->hasInputMethodContext())
         return &target->inputMethodContext();
 
     return 0;
 }
 
@@ skipping 18 matching lines @@
 }
 
 void WebViewImpl::didHideCandidateWindow()
 {
     if (InputMethodContext* context = inputMethodContext())
         context->dispatchCandidateWindowHideEvent();
 }
 
 bool WebViewImpl::selectionTextDirection(WebTextDirection& start, WebTextDirection& end) const
 {
-    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    const LocalFrame* frame = toLocalFrame(focusedCoreFrame());
     if (!frame)
         return false;
     FrameSelection& selection = frame->selection();
     if (!selection.toNormalizedRange())
         return false;
     start = toWebTextDirection(selection.start().primaryDirection());
     end = toWebTextDirection(selection.end().primaryDirection());
     return true;
 }
 
 bool WebViewImpl::isSelectionAnchorFirst() const
 {
-    if (const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame()))
+    if (const LocalFrame* frame = toLocalFrame(focusedCoreFrame()))
         return frame->selection().selection().isBaseFirst();
     return false;
 }
 
 WebVector<WebCompositionUnderline> WebViewImpl::compositionUnderlines() const
 {
-    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    const LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     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) {
         CompositionUnderline underline = underlines[index];
         results[index] = WebCompositionUnderline(underline.startOffset, underline.endOffset, static_cast<WebColor>(underline.color.rgb()), underline.thick, static_cast<WebColor>(underline.backgroundColor.rgb()));
     }
     return results;
 }
 
 WebColor WebViewImpl::backgroundColor() const
 {
     if (isTransparent())
         return Color::transparent;
     if (!m_page)
         return m_baseBackgroundColor;
     if (!m_page->mainFrame())
         return m_baseBackgroundColor;
     if (!m_page->mainFrame()->isLocalFrame())
         return m_baseBackgroundColor;
     FrameView* view = m_page->deprecatedLocalMainFrame()->view();
     return view->documentBackgroundColor().rgb();
 }
 
 bool WebViewImpl::caretOrSelectionRange(size_t* location, size_t* length)
 {
-    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    const LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     if (!focused)
         return false;
 
     PlainTextRange selectionOffsets = focused->inputMethodController().getSelectionOffsets();
     if (selectionOffsets.isNull())
         return false;
 
     *location = selectionOffsets.start();
     *length = selectionOffsets.length();
     return true;
 }
 
 void WebViewImpl::setTextDirection(WebTextDirection direction)
 {
     // The Editor::setBaseWritingDirection() function checks if we can change
     // the text direction of the selected node and updates its DOM "dir"
     // attribute and its CSS "direction" property.
     // So, we just call the function as Safari does.
-    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    const LocalFrame* focused = toLocalFrame(focusedCoreFrame());
     if (!focused)
         return;
 
     Editor& editor = focused->editor();
     if (!editor.canEdit())
         return;
 
     switch (direction) {
     case WebTextDirectionDefault:
         editor.setBaseWritingDirection(NaturalWritingDirection);
@@ skipping 108 matching lines @@
         relativeToFrame = mainFrame();
     Frame* frame = toWebLocalFrameImpl(relativeToFrame)->frame();
     frame = frame->tree().find(name);
     if (!frame || !frame->isLocalFrame())
         return 0;
     return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
 }
 
 WebFrame* WebViewImpl::focusedFrame()
 {
-    return WebFrame::fromFrame(focusedWebCoreFrame());
+    return WebFrame::fromFrame(focusedCoreFrame());
 }
 
 void WebViewImpl::setFocusedFrame(WebFrame* frame)
 {
     if (!frame) {
         // Clears the focused frame if any.
-        Frame* focusedFrame = focusedWebCoreFrame();
+        Frame* focusedFrame = focusedCoreFrame();
         if (focusedFrame && focusedFrame->isLocalFrame())
             toLocalFrame(focusedFrame)->selection().setFocused(false);
         return;
     }
-    LocalFrame* webcoreFrame = toWebLocalFrameImpl(frame)->frame();
-    webcoreFrame->page()->focusController().setFocusedFrame(webcoreFrame);
+    LocalFrame* coreFrame = toWebLocalFrameImpl(frame)->frame();
+    coreFrame->page()->focusController().setFocusedFrame(coreFrame);
 }
 
 void WebViewImpl::setInitialFocus(bool reverse)
 {
     if (!m_page)
         return;
     Frame* frame = page()->focusController().focusedOrMainFrame();
     if (frame->isLocalFrame()) {
         if (Document* document = toLocalFrame(frame)->document())
             document->setFocusedElement(nullptr);
     }
     page()->focusController().setInitialFocus(reverse ? FocusTypeBackward : FocusTypeForward);
 }
 
 void WebViewImpl::clearFocusedElement()
 {
-    RefPtr<Frame> frame = focusedWebCoreFrame();
+    RefPtr<Frame> frame = focusedCoreFrame();
     if (!frame || !frame->isLocalFrame())
         return;
 
     LocalFrame* localFrame = toLocalFrame(frame.get());
 
     RefPtrWillBeRawPtr<Document> document = localFrame->document();
     if (!document)
         return;
 
     RefPtrWillBeRawPtr<Element> oldFocusedElement = document->focusedElement();
@@ skipping 900 matching lines @@
 
     page()->contextMenuController().clearContextMenu();
     m_contextMenuAllowed = true;
     if (LocalFrame* focusedFrame = toLocalFrame(page()->focusController().focusedOrMainFrame()))
         focusedFrame->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
 }
 
 void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
 {
-    LocalFrame* localFrame = toLocalFrame(focusedWebCoreFrame());
+    LocalFrame* localFrame = toLocalFrame(focusedCoreFrame());
     if (!localFrame)
         return;
     SmartClipData clipData = SmartClip(localFrame).dataForRect(rect);
     clipText = clipData.clipData();
     clipRect = clipData.rect();
 
     WebLocalFrameImpl* frame = mainFrameImpl();
     if (!frame)
         return;
     WebPoint startPoint(rect.x, rect.y);
@@ skipping 673 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