Remove lots of code from the WebWidget/WebView/WebFrame layer.

sky/engine/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 120 matching lines @@
     m_spellCheckClient = spellCheckClient;
 }
 
 WebViewImpl::WebViewImpl(WebViewClient* client)
     : m_client(client)
     , m_spellCheckClient(0)
     , m_chromeClientImpl(this)
     , m_editorClientImpl(this)
     , m_spellCheckerClientImpl(this)
     , m_fixedLayoutSizeLock(false)
-    , m_doingDragAndDrop(false)
     , m_ignoreInputEvents(false)
     , m_compositorDeviceScaleFactorOverride(0)
     , m_rootLayerScale(1)
     , m_suppressNextKeypressEvent(false)
     , m_imeAcceptEvents(true)
     , m_isTransparent(false)
     , m_tabsToLinks(false)
     , m_rootLayer(0)
     , m_matchesHeuristicsForGpuRasterization(false)
     , m_recreatingGraphicsContext(false)
@@ skipping 44 matching lines @@
 }
 
 void WebViewImpl::handleMouseLeave(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     m_client->setMouseOverURL(WebURL());
     PageWidgetEventHandler::handleMouseLeave(mainFrame, event);
 }
 
 void WebViewImpl::handleMouseDown(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
-    m_lastMouseDownPoint = WebPoint(event.x, event.y);
-
     PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
     if (event.button == WebMouseEvent::ButtonLeft && m_mouseCaptureNode)
         m_mouseCaptureGestureToken = mainFrame.eventHandler().takeLastMouseDownGestureToken();
 }
 
 void WebViewImpl::handleMouseUp(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     PageWidgetEventHandler::handleMouseUp(mainFrame, event);
 }
@@ skipping 175 matching lines @@
 {
     m_continuousPaintingEnabled = enabled;
     m_client->scheduleAnimation();
 }
 
 void WebViewImpl::setShowScrollBottleneckRects(bool show)
 {
     m_showScrollBottleneckRects = show;
 }
 
-void WebViewImpl::getSelectionRootBounds(WebRect& bounds) const
-{
-    const LocalFrame* frame = focusedCoreFrame();
-    if (!frame)
-        return;
-
-    Element* root = frame->selection().rootEditableElementOrDocumentElement();
-    if (!root)
-        return;
-
-    IntRect boundingBox = root->pixelSnappedBoundingBox();
-    boundingBox = root->document().frame()->view()->contentsToWindow(boundingBox);
-    bounds = boundingBox;
-}
-
 void WebViewImpl::acceptLanguagesChanged()
 {
     if (!page())
         return;
 
     page()->acceptLanguagesChanged();
 }
 
 bool WebViewImpl::handleKeyEvent(const WebKeyboardEvent& event)
 {
@@ skipping 64 matching lines @@
     // events.
     if (evt.isSystemKey())
         return false;
 
     if (!suppress && !handler.keyEvent(evt))
         return keyEventDefault(event);
 
     return true;
 }
 
-WebRect WebViewImpl::computeBlockBounds(const WebRect& rect, bool ignoreClipping)
-{
-    if (!mainFrameImpl())
-        return WebRect();
-
-    // Use the rect-based hit test to find the node.
-    IntPoint point = mainFrameImpl()->frameView()->windowToContents(IntPoint(rect.x, rect.y));
-    HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | (ignoreClipping ? HitTestRequest::IgnoreClipping : 0);
-    HitTestResult result = mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(point, hitType, IntSize(rect.width, rect.height));
-
-    Node* node = result.innerNonSharedNode();
-    if (!node)
-        return WebRect();
-
-    // Find the block type node based on the hit node.
-    // FIXME: This wants to walk composed tree with NodeRenderingTraversal::parent().
-    while (node && (!node->renderer() || node->renderer()->isInline()))
-        node = NodeRenderingTraversal::parent(node);
-
-    // Return the bounding box in the window coordinate system.
-    if (node) {
-        IntRect rect = node->Node::pixelSnappedBoundingBox();
-        LocalFrame* frame = node->document().frame();
-        return frame->view()->contentsToWindow(rect);
-    }
-    return WebRect();
-}
-
-WebRect WebViewImpl::widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin)
-{
-    WebSize maxSize;
-    if (mainFrame())
-        maxSize = mainFrame()->contentsSize();
-    int leftMargin = targetMargin;
-    int rightMargin = targetMargin;
-
-    const int absoluteSourceX = source.x;
-    if (leftMargin > absoluteSourceX) {
-        leftMargin = absoluteSourceX;
-        rightMargin = std::max(leftMargin, minimumMargin);
-    }
-
-    const int maximumRightMargin = maxSize.width - (source.width + absoluteSourceX);
-    if (rightMargin > maximumRightMargin) {
-        rightMargin = maximumRightMargin;
-        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(newX + newWidth <= maxSize.width);
-
-    return WebRect(newX, source.y, newWidth, source.height);
-}
-
-void WebViewImpl::computeScaleAndScrollForBlockRect(const WebPoint& hitPoint, const WebRect& blockRect, float padding, float defaultScaleWhenAlreadyLegible, float& scale, WebPoint& scroll)
-{
-    //FIXME(sky)
-}
-
 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)
 {
     LocalFrame* frame = 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);
@@ skipping 103 matching lines @@
         m_page.clear();
     }
 
     // Reset the delegate to prevent notifications being sent as we're being
     // deleted.
     m_client = 0;
 
     deref();  // Balances ref() acquired in WebView::create
 }
 
-void WebViewImpl::willStartLiveResize()
-{
-    // FIXME(sky): Remove
-}
-
 WebSize WebViewImpl::size()
 {
     return m_size;
 }
 
 WebLocalFrameImpl* WebViewImpl::localFrameRootTemporary() const
 {
     // FIXME(sky): remove
     return WebLocalFrameImpl::fromFrame(page()->mainFrame());
 }
@@ skipping 15 matching lines @@
 
     FrameView* view = localFrameRootTemporary()->frameView();
     if (!view)
         return;
 
     m_size = newSize;
     performResize();
     sendResizeEventAndRepaint();
 }
 
-void WebViewImpl::willEndLiveResize()
-{
-    // FIXME(sky): Remove
-}
-
 void WebViewImpl::beginFrame(const WebBeginFrameArgs& frameTime)
 {
     TRACE_EVENT0("blink", "WebViewImpl::beginFrame");
 
     WebBeginFrameArgs validFrameTime(frameTime);
     if (!validFrameTime.lastFrameTimeMonotonic)
         validFrameTime.lastFrameTimeMonotonic = monotonicallyIncreasingTime();
 
     // Create synthetic wheel events as necessary for fling.
     if (m_gestureAnimation) {
@@ skipping 14 matching lines @@
     WTF_LOG(ScriptedAnimationController, "WebViewImpl::beginFrame: page = %d", !m_page ? 0 : 1);
     if (!m_page)
         return;
 
     PageWidgetDelegate::animate(m_page.get(), validFrameTime.lastFrameTimeMonotonic);
 
     if (m_continuousPaintingEnabled)
         m_client->scheduleAnimation();
 }
 
-void WebViewImpl::didCommitFrameToCompositor()
-{
-}
-
 void WebViewImpl::layout()
 {
     TRACE_EVENT0("blink", "WebViewImpl::layout");
     if (!localFrameRootTemporary())
         return;
     PageWidgetDelegate::layout(m_page.get(), localFrameRootTemporary()->frame());
 }
 
 void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect)
 {
     double paintStart = currentTime();
     PageWidgetDelegate::paint(m_page.get(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
     double paintEnd = currentTime();
     double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
     Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintDurationMS", (paintEnd - paintStart) * 1000, 0, 120, 30);
     Platform::current()->histogramCustomCounts("Renderer4.SoftwarePaintMegapixPerSecond", pixelsPerSec / 1000000, 10, 210, 30);
 }
 
 bool WebViewImpl::isTrackingRepaints() const
 {
     if (!page())
         return false;
     FrameView* view = page()->mainFrame()->view();
     return view->isTrackingPaintInvalidations();
 }
 
-void WebViewImpl::themeChanged()
-{
-    if (!page())
-        return;
-    FrameView* view = page()->mainFrame()->view();
-
-    WebRect damagedRect(0, 0, m_size.width, m_size.height);
-    view->invalidateRect(damagedRect);
-}
-
 bool WebViewImpl::hasHorizontalScrollbar()
 {
     // FIXME(sky): Remove
     return false;
 }
 
 bool WebViewImpl::hasVerticalScrollbar()
 {
     // FIXME(sky): Remove
     return false;
@@ skipping 45 matching lines @@
     case WebInputEvent::TouchCancel:
         return EventTypeNames::touchcancel;
     default:
         return String("unknown");
     }
 }
 
 bool WebViewImpl::handleInputEvent(const WebInputEvent& inputEvent)
 {
     TRACE_EVENT1("input", "WebViewImpl::handleInputEvent", "type", inputTypeToName(inputEvent.type).ascii().data());
-    // If we've started a drag and drop operation, ignore input events until
-    // we're done.
-    if (m_doingDragAndDrop)
-        return true;
 
     // Report the event to be NOT processed by WebKit, so that the browser can handle it appropriately.
     if (m_ignoreInputEvents)
         return false;
 
     TemporaryChange<const WebInputEvent*> currentEventChange(m_currentInputEvent, &inputEvent);
 
     if (m_mouseCaptureNode && WebInputEvent::isMouseEventType(inputEvent.type)) {
         TRACE_EVENT1("input", "captured mouse event", "type", inputEvent.type);
         // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.
@@ skipping 271 matching lines @@
         flags |= WebTextInputFlagSpellcheckOff;
 
     return flags;
 }
 
 WebString WebViewImpl::inputModeOfFocusedElement()
 {
     return WebString();
 }
 
-bool WebViewImpl::selectionBounds(WebRect& anchor, WebRect& focus) const
-{
-    const LocalFrame* localFrame = focusedCoreFrame();
-    if (!localFrame)
-        return false;
-
-    FrameSelection& selection = localFrame->selection();
-
-    if (selection.isCaret()) {
-        anchor = focus = selection.absoluteCaretBounds();
-    } else {
-        RefPtr<Range> selectedRange = selection.toNormalizedRange();
-        if (!selectedRange)
-            return false;
-
-        RefPtr<Range> range(Range::create(selectedRange->startContainer()->document(),
-            selectedRange->startContainer(),
-            selectedRange->startOffset(),
-            selectedRange->startContainer(),
-            selectedRange->startOffset()));
-        anchor = localFrame->editor().firstRectForRange(range.get());
-
-        range = Range::create(selectedRange->endContainer()->document(),
-            selectedRange->endContainer(),
-            selectedRange->endOffset(),
-            selectedRange->endContainer(),
-            selectedRange->endOffset());
-        focus = localFrame->editor().firstRectForRange(range.get());
-    }
-
-    IntRect scaledAnchor(localFrame->view()->contentsToWindow(anchor));
-    IntRect scaledFocus(localFrame->view()->contentsToWindow(focus));
-
-    anchor = scaledAnchor;
-    focus = scaledFocus;
-
-    if (!selection.selection().isBaseFirst())
-        std::swap(anchor, focus);
-    return true;
-}
-
 InputMethodContext* WebViewImpl::inputMethodContext()
 {
     if (!m_imeAcceptEvents)
         return 0;
 
     LocalFrame* focusedFrame = focusedCoreFrame();
     if (!focusedFrame)
         return 0;
 
     Element* target = focusedFrame->document()->focusedElement();
@@ skipping 14 matching lines @@
     if (InputMethodContext* context = inputMethodContext())
         context->dispatchCandidateWindowUpdateEvent();
 }
 
 void WebViewImpl::didHideCandidateWindow()
 {
     if (InputMethodContext* context = inputMethodContext())
         context->dispatchCandidateWindowHideEvent();
 }
 
-bool WebViewImpl::selectionTextDirection(WebTextDirection& start, WebTextDirection& end) const
-{
-    const LocalFrame* frame = 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 = focusedCoreFrame())
-        return frame->selection().selection().isBaseFirst();
-    return false;
-}
-
 WebVector<WebCompositionUnderline> WebViewImpl::compositionUnderlines() const
 {
     const LocalFrame* focused = 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;
     FrameView* view = m_page->mainFrame()->view();
     return view->documentBackgroundColor().rgb();
 }
 
-bool WebViewImpl::caretOrSelectionRange(size_t* location, size_t* length)
-{
-    const LocalFrame* focused = 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 = focusedCoreFrame();
-    if (!focused)
-        return;
-
-    Editor& editor = focused->editor();
-    if (!editor.canEdit())
-        return;
-
-    switch (direction) {
-    case WebTextDirectionDefault:
-        editor.setBaseWritingDirection(NaturalWritingDirection);
-        break;
-
-    case WebTextDirectionLeftToRight:
-        editor.setBaseWritingDirection(LeftToRightWritingDirection);
-        break;
-
-    case WebTextDirectionRightToLeft:
-        editor.setBaseWritingDirection(RightToLeftWritingDirection);
-        break;
-
-    default:
-        notImplemented();
-        break;
-    }
-}
-
 // WebView --------------------------------------------------------------------
 
 WebSettingsImpl* WebViewImpl::settingsImpl()
 {
     if (!m_webSettings)
         m_webSettings = adoptPtr(new WebSettingsImpl(&m_page->settings()));
     ASSERT(m_webSettings);
     return m_webSettings.get();
 }
 
@@ skipping 78 matching lines @@
         return;
 
     // If a text field has focus, we need to make sure the selection controller
     // knows to remove selection from it. Otherwise, the text field is still
     // processing keyboard events even though focus has been moved to the page and
     // keystrokes get eaten as a result.
     if (oldFocusedElement->isContentEditable())
         localFrame->selection().clear();
 }
 
-void WebViewImpl::scrollFocusedNodeIntoRect(const WebRect& rect)
-{
-    LocalFrame* frame = page()->mainFrame();
-    Element* element = focusedElement();
-    if (!frame || !frame->view() || !element)
-        return;
-
-    float scale;
-    IntPoint scroll;
-    bool needAnimation;
-    computeScaleAndScrollForFocusedNode(element, scale, scroll, needAnimation);
-}
-
-void WebViewImpl::computeScaleAndScrollForFocusedNode(Node* focusedNode, float& newScale, IntPoint& newScroll, bool& needAnimation)
-{
-    //FIXME(sky)
-}
-
 void WebViewImpl::advanceFocus(bool reverse)
 {
     page()->focusController().advanceFocus(reverse ? FocusTypeBackward : FocusTypeForward);
 }
 
 IntPoint WebViewImpl::clampOffsetAtScale(const IntPoint& offset, float scale)
 {
     FrameView* view = mainFrameImpl()->frameView();
     if (!view)
         return offset;
 
     return view->clampOffsetAtScale(offset, scale);
 }
 
-void WebViewImpl::setMainFrameScrollOffset(const WebPoint& origin)
-{
-    updateMainFrameScrollPosition(origin, false);
-}
-
 float WebViewImpl::deviceScaleFactor() const
 {
     if (!page())
         return 1;
 
     return page()->deviceScaleFactor();
 }
 
 void WebViewImpl::setDeviceScaleFactor(float scaleFactor)
 {
@@ skipping 21 matching lines @@
 }
 
 IntSize WebViewImpl::contentsSize() const
 {
     RenderView* root = page()->mainFrame()->contentRenderer();
     if (!root)
         return IntSize();
     return root->documentRect().size();
 }
 
-WebSize WebViewImpl::contentsPreferredMinimumSize()
-{
-    Document* document = m_page->mainFrame()->document();
-    if (!document || !document->renderView() || !document->documentElement())
-        return WebSize();
-
-    layout();
-    FontCachePurgePreventer fontCachePurgePreventer; // Required by minPreferredLogicalWidth().
-    return IntSize(document->renderView()->minPreferredLogicalWidth(), document->documentElement()->scrollHeight());
-}
-
-void WebViewImpl::resetScrollAndScaleState()
-{
-    // FIXME(sky): Remove
-}
-
-void WebViewImpl::setFixedLayoutSize(const WebSize& layoutSize)
-{
-    if (!page())
-        return;
-
-    LocalFrame* frame = page()->mainFrame();
-    if (!frame)
-        return;
-
-    RefPtr<FrameView> view = frame->view();
-    if (!view)
-        return;
-
-    m_fixedLayoutSizeLock = layoutSize.width || layoutSize.height;
-
-    if (m_fixedLayoutSizeLock)
-        view->setLayoutSize(layoutSize);
-    else
-        updateMainFrameLayoutSize();
-}
-
 WebHitTestResult WebViewImpl::hitTestResultAt(const WebPoint& point)
 {
     return coreHitTestResultAt(point);
 }
 
 HitTestResult WebViewImpl::coreHitTestResultAt(const WebPoint& point)
 {
     IntPoint scaledPoint = point;
     return hitTestResultForWindowPos(scaledPoint);
 }
 
-void WebViewImpl::copyImageAt(const WebPoint& point)
-{
-    if (!m_page)
-        return;
-
-    HitTestResult result = hitTestResultForWindowPos(point);
-
-    if (result.absoluteImageURLIncludingCanvasDataURL().isEmpty()) {
-        // There isn't actually an image at these coordinates.  Might be because
-        // the window scrolled while the context menu was open or because the page
-        // changed itself between when we thought there was an image here and when
-        // we actually tried to retreive the image.
-        //
-        // FIXME: implement a cache of the most recent HitTestResult to avoid having
-        //        to do two hit tests.
-        return;
-    }
-
-    m_page->mainFrame()->editor().copyImage(result);
-}
-
-void WebViewImpl::saveImageAt(const WebPoint& point)
-{
-    if (!m_page)
-        return;
-
-    KURL url = hitTestResultForWindowPos(point).absoluteImageURLIncludingCanvasDataURL();
-
-    if (url.isEmpty())
-        return;
-
-    ResourceRequest request(url);
-    request.setRequestContext(WebURLRequest::RequestContextDownload);
-    m_page->mainFrame()->loaderClient()->loadURLExternally(
-        request, NavigationPolicyDownloadTo, WebString());
-}
-
-void WebViewImpl::dragSourceSystemDragEnded()
-{
-    // FIXME(sky): Remove
-    // It's possible for us to get this callback while not doing a drag if
-    // it's from a previous page that got unloaded.
-    if (m_doingDragAndDrop)
-        m_doingDragAndDrop = false;
-}
-
 void WebViewImpl::spellingMarkers(WebVector<uint32_t>* markers)
 {
     Vector<uint32_t> result;
     LocalFrame* frame = m_page->mainFrame();
     const DocumentMarkerVector& documentMarkers = frame->document()->markers().markers();
     for (size_t i = 0; i < documentMarkers.size(); ++i)
         result.append(documentMarkers[i]->hash());
     markers->assign(result);
 }
 
@@ skipping 18 matching lines @@
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     m_client->didInvalidateRect(damagedRect);
 }
 
 void WebViewImpl::setCompositorDeviceScaleFactorOverride(float deviceScaleFactor)
 {
     m_compositorDeviceScaleFactorOverride = deviceScaleFactor;
 }
 
-void WebViewImpl::setRootLayerTransform(const WebSize& rootLayerOffset, float rootLayerScale)
-{
-    if (m_rootLayerScale == rootLayerScale && m_rootLayerOffset == rootLayerOffset)
-        return;
-    m_rootLayerScale = rootLayerScale;
-    m_rootLayerOffset = rootLayerOffset;
-    if (mainFrameImpl())
-        mainFrameImpl()->setInputEventsTransformForEmulation(m_rootLayerOffset, m_rootLayerScale);
-    updateRootLayerTransform();
-}
-
-void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
-{
-}
-
 void WebViewImpl::setIsTransparent(bool isTransparent)
 {
     // Set any existing frames to be transparent.
     m_page->mainFrame()->view()->setTransparent(isTransparent);
 
     // Future frames check this to know whether to be transparent.
     m_isTransparent = isTransparent;
 }
 
 bool WebViewImpl::isTransparent() const
@@ skipping 24 matching lines @@
 bool WebViewImpl::isActive() const
 {
     return page() ? page()->focusController().isActive() : false;
 }
 
 void WebViewImpl::setDomainRelaxationForbidden(bool forbidden, const WebString& scheme)
 {
     SchemeRegistry::setDomainRelaxationForbiddenForURLScheme(forbidden, String(scheme));
 }
 
-void WebViewImpl::setOpenedByDOM()
-{
-    m_page->setOpenedByDOM();
-}
-
-void WebViewImpl::setSelectionColors(unsigned activeBackgroundColor,
-                                     unsigned activeForegroundColor,
-                                     unsigned inactiveBackgroundColor,
-                                     unsigned inactiveForegroundColor) {
-}
-
 void WebViewImpl::didCommitLoad(bool isNewNavigation, bool isNavigationWithinPage)
 {
     endActiveFlingAnimation();
     m_userGestureObserved = false;
     if (!isNavigationWithinPage)
         UserGestureIndicator::clearProcessedUserGestureSinceLoad();
 }
 
 void WebViewImpl::layoutUpdated(WebLocalFrameImpl* webframe)
 {
@@ skipping 51 matching lines @@
 void WebViewImpl::invalidateRect(const IntRect& rect)
 {
     m_client->didInvalidateRect(rect);
 }
 
 void WebViewImpl::scheduleAnimation()
 {
     m_client->scheduleAnimation();
 }
 
-void WebViewImpl::updateMainFrameScrollPosition(const IntPoint& scrollPosition, bool programmaticScroll)
-{
-    // FIXME(sky): Remove
-}
-
-void WebViewImpl::updateRootLayerTransform()
-{
-    // FIXME(sky): Remove
-}
-
 bool WebViewImpl::detectContentOnTouch(const WebPoint& position)
 {
     HitTestResult touchHit = hitTestResultForWindowPos(position);
 
     if (touchHit.isContentEditable())
         return false;
 
     Node* node = touchHit.innerNode();
     if (!node || !node->isTextNode())
         return false;
@@ skipping 15 matching lines @@
 void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,
                                      bool isInitialState) {
     if (!page())
         return;
 
     ASSERT(visibilityState == WebPageVisibilityStateVisible || visibilityState == WebPageVisibilityStateHidden);
     m_page->setVisibilityState(static_cast<PageVisibilityState>(static_cast<int>(visibilityState)), isInitialState);
 }
 
 } // namespace blink