Route selection bounds updates through WebLayerTreeView

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 61 matching lines @@
 #include "core/page/InjectedStyleSheets.h"
 #include "core/page/Page.h"
 #include "core/page/PagePopupClient.h"
 #include "core/page/PointerLockController.h"
 #include "core/page/ScopedPageLoadDeferrer.h"
 #include "core/page/TouchDisambiguation.h"
 #include "core/rendering/FastTextAutosizer.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/RenderWidget.h"
 #include "core/rendering/TextAutosizer.h"
+#include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "modules/device_orientation/DeviceOrientationInspectorAgent.h"
 #include "modules/encryptedmedia/MediaKeysController.h"
 #include "modules/indexeddb/InspectorIndexedDBAgent.h"
 #include "modules/push_messaging/PushController.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
 #include "platform/ContextMenu.h"
 #include "platform/ContextMenuItem.h"
 #include "platform/Cursor.h"
 #include "platform/KeyboardCodes.h"
@@ skipping 24 matching lines @@
 #include "public/web/WebActiveWheelFlingParameters.h"
 #include "public/web/WebAutofillClient.h"
 #include "public/web/WebFrameClient.h"
 #include "public/web/WebHitTestResult.h"
 #include "public/web/WebInputElement.h"
 #include "public/web/WebMediaPlayerAction.h"
 #include "public/web/WebNode.h"
 #include "public/web/WebPlugin.h"
 #include "public/web/WebPluginAction.h"
 #include "public/web/WebRange.h"
+#include "public/web/WebSelection.h"
 #include "public/web/WebTextInputInfo.h"
 #include "public/web/WebViewClient.h"
 #include "public/web/WebWindowFeatures.h"
 #include "web/CompositionUnderlineVectorBuilder.h"
 #include "web/ContextFeaturesClientImpl.h"
 #include "web/DatabaseClientImpl.h"
 #include "web/FullscreenController.h"
 #include "web/GraphicsLayerFactoryChromium.h"
 #include "web/LinkHighlight.h"
 #include "web/LocalFileSystemClient.h"
@@ skipping 1579 matching lines @@
 }
 
 void WebViewImpl::layout()
 {
     TRACE_EVENT0("webkit", "WebViewImpl::layout");
     PageWidgetDelegate::layout(m_page.get());
     updateLayerTreeBackgroundColor();
 
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->updateGeometry();
+
+    updateLayerTreeSelection();
 }
 
 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();
     PageWidgetDelegate::paint(m_page.get(), pageOverlays(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
@@ skipping 2265 matching lines @@
         m_rootTransformLayer = m_page->mainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
 
     if (m_rootTransformLayer) {
         WebCore::TransformationMatrix transform;
         transform.translate(m_rootLayerOffset.width, m_rootLayerOffset.height);
         transform = transform.scale(m_rootLayerScale);
         m_rootTransformLayer->setTransform(transform);
     }
 }
 
+static FloatPoint convertTargetPointToCompositedLayerPoint(IntPoint point, RenderObject* targetRenderer, RenderObject* compositedRenderer)
+{
+    point = targetRenderer->frame()->view()->contentsToWindow(point);
+    point = compositedRenderer->frame()->view()->windowToContents(point);
+    return compositedRenderer->absoluteToLocal(point, UseTransforms);
+}
+
+static bool computeCompositedLayerAndRect(Node* node, IntRect absoluteRect, int& layerId, WebRect& layerRect)

[aelias_OOO_until_Jul13, 2014/06/12 06:02:01]

Looks very similar to the logic in LinkHighlight.cpp, please create some common
code and refactor link highlight to call into it.

[jdduke (slow), 2014/06/12 18:03:20]

Any suggestions on where to place to put such code? I don't see a ton of free
functions floating around, would it make sense to attach a couple static utility
methods to RenderLayerCompositor?

+{
+    if (!node || !node->renderer())
+        return false;
+
+    // Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
+    // to find a suitable layer.
+    RenderObject* renderer = node->renderer();
+    RenderLayer* renderLayer;
+    do {
+        renderLayer = renderer->enclosingLayer()->enclosingCompositingLayerForRepaint();
+        if (!renderLayer) {
+            renderer = renderer->frame()->ownerRenderer();
+            if (!renderer)
+                return false;
+        }
+    } while (!renderLayer);
+
+    CompositedLayerMappingPtr compositedLayerMapping = renderLayer->compositingState() == PaintsIntoGroupedBacking ? renderLayer->groupedMapping() : renderLayer->compositedLayerMapping();
+    GraphicsLayer* graphicsLayer = renderLayer->compositingState() == PaintsIntoGroupedBacking ? compositedLayerMapping->squashingLayer() : compositedLayerMapping->mainGraphicsLayer();
+
+    if (!graphicsLayer->drawsContent()) {
+        if (renderLayer->scrollableArea() && renderLayer->scrollableArea()->usesCompositedScrolling()) {
+            ASSERT(renderLayer->hasCompositedLayerMapping() && renderLayer->compositedLayerMapping()->scrollingContentsLayer());
+            graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
+        }
+    }
+
+    layerId = graphicsLayer->platformLayer()->id();
+
+    absoluteRect.move(-graphicsLayer->offsetFromRenderer());
+
+    FloatQuad layerQuad;
+    layerQuad.setP1(convertTargetPointToCompositedLayerPoint(absoluteRect.minXMinYCorner(), node->renderer(), renderLayer->renderer()));
+    layerQuad.setP2(convertTargetPointToCompositedLayerPoint(absoluteRect.maxXMinYCorner(), node->renderer(), renderLayer->renderer()));
+    layerQuad.setP3(convertTargetPointToCompositedLayerPoint(absoluteRect.maxXMaxYCorner(), node->renderer(), renderLayer->renderer()));
+    layerQuad.setP4(convertTargetPointToCompositedLayerPoint(absoluteRect.minXMaxYCorner(), node->renderer(), renderLayer->renderer()));
+    layerRect = layerQuad.enclosingBoundingBox();
+
+    return true;
+}
+
+void WebViewImpl::updateLayerTreeSelection()
+{
+    if (!m_layerTreeView || !settings()->compositedSelectionUpdatesEnabled())
+        return;
+
+    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    if (!frame || !frame->selection().isCaretOrRange())
+        return m_layerTreeView->clearSelection();
+
+    FrameSelection& selection = frame->selection();
+
+    // TODO(jdduke): Cache selection and compare?
+    if (selection.isCaret()) {
+        WebSelection webSelection;
+        if (!computeCompositedLayerAndRect(selection.rootEditableElementOrDocumentElement(),
+            selection.absoluteCaretBounds(),
+            webSelection.anchorLayerId,
+            webSelection.anchorRectInLayer)) {
+            return m_layerTreeView->clearSelection();
+        }
+
+        // TODO(jdduke): Populate editable bounds.
+        webSelection.type = WebSelection::TypeInsertion;
+        m_layerTreeView->registerSelection(webSelection);
+        return;
+    }
+
+    RefPtrWillBeRawPtr<Range> selectedRange = selection.toNormalizedRange();
+    if (!selectedRange)
+        return m_layerTreeView->clearSelection();
+
+    WebSelection webSelection;
+
+    RefPtrWillBeRawPtr<Range> range(Range::create(selectedRange->startContainer()->document(),
+        selectedRange->startContainer(),
+        selectedRange->startOffset(),
+        selectedRange->startContainer(),
+        selectedRange->startOffset()));
+    IntRect anchor = frame->editor().firstRectForRange(range.get());
+    if (!computeCompositedLayerAndRect(selection.start().anchorNode(),
+        anchor,
+        webSelection.anchorLayerId,
+        webSelection.anchorRectInLayer)) {
+        return m_layerTreeView->clearSelection();
+    }
+
+    range = Range::create(selectedRange->endContainer()->document(),
+        selectedRange->endContainer(),
+        selectedRange->endOffset(),
+        selectedRange->endContainer(),
+        selectedRange->endOffset());
+    IntRect focus = frame->editor().firstRectForRange(range.get());
+    if (!computeCompositedLayerAndRect(selection.end().anchorNode(),
+        focus,
+        webSelection.focusLayerId,
+        webSelection.focusRectInLayer)) {
+        return m_layerTreeView->clearSelection();
+    }
+
+    // TODO(jdduke): Populate editable bounds.
+    webSelection.type = WebSelection::TypeSelection;
+    webSelection.anchorDirection = selection.start().primaryDirection() == RTL ? WebTextDirectionRightToLeft : WebTextDirectionLeftToRight;
+    webSelection.focusDirection = selection.end().primaryDirection() == RTL ? WebTextDirectionRightToLeft : WebTextDirectionLeftToRight;
+    webSelection.anchorIsFirst = selection.selection().isBaseFirst();
+    m_layerTreeView->registerSelection(webSelection);
+}
+
 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 81 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