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 105 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/PopupContainer.h"
@@ skipping 1575 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();

[abarth-chromium, 2014/06/13 21:38:15]

This shouldn't be a separate set in WebViewImpl::layout.  It should be properly
integrated with the rest of the engine, not glued on in a separate phase.

[jdduke (slow), 2014/06/24 18:22:07]

Done.

 }
 
 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 2271 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 bool computeCompositedLayerAndRect(Node* node, IntRect absoluteRect, int& layerId, WebRect& layerRect)
+{
+    RenderLayer* renderLayer;
+    GraphicsLayer* graphicsLayer;
+    if (!RenderLayerCompositor::computeEnclosingCompositingLayer(node, renderLayer, graphicsLayer))
+        return false;
+
+    ASSERT(renderLayer);
+    ASSERT(graphicsLayer);
+
+    absoluteRect.move(-graphicsLayer->offsetFromRenderer());
+    FloatQuad absoluteQuad(absoluteRect);
+    FloatQuad layerQuad;
+    RenderLayerCompositor::convertTargetSpaceQuadToCompositedLayer(absoluteQuad, node->renderer(), renderLayer->renderer(), layerQuad);
+
+    layerRect = layerQuad.enclosingBoundingBox();
+    layerId = graphicsLayer->platformLayer()->id();
+
+    return true;
+}

[abarth-chromium, 2014/06/13 21:38:15]

We won't need to do this work in the correct design either.

Lots of code in this CL is trying to search around for the right GraphicsLayer
to manipulate.  In the correct design, we won't need to search for the right
graphics layer because we'll be in the middle of the correct tree walk and be at
the point in the walk when we're touching the right graphics layer.

[jdduke (slow), 2014/06/24 18:22:07]

How will we know this, and where is the correct tree walk for such
determination? As the selection is sparse and more or less a singleton in the
tree, it's not really clear to me how this should properly fit into one of the
regular tree walks given the current state of the FrameSelection.

+
+void WebViewImpl::updateLayerTreeSelection()
+{
+    if (!m_layerTreeView || !settings()->compositedSelectionUpdatesEnabled())
+        return;
+
+    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    if (!frame || !frame->selection().isCaretOrRange())
+        return m_layerTreeView->clearSelection();

[abarth-chromium, 2014/06/13 21:38:15]

Instead of polling blink_core to see whether
!frame->selection().isCaretOrRange(), the system that changes the selection
should send out a notification when it clears its selection.

[jdduke (slow), 2014/06/24 18:22:07]

Done.

+
+    FrameSelection& selection = frame->selection();
+
+    if (selection.isCaret()) {
+        WebSelection webSelection;
+        if (!computeCompositedLayerAndRect(selection.rootEditableElementOrDocumentElement(),
+            selection.absoluteCaretBounds(),
+            webSelection.anchorLayerId,
+            webSelection.anchorRectInLayer)) {
+            return m_layerTreeView->clearSelection();
+        }
+
+        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();
+    }
+
+    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