Plumb selection bounds as a single unit

Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 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 4189 matching lines @@
     virtual void setDeviceScaleFactor(float) override { }
     virtual float deviceScaleFactor() const  override { return 1.f; }
     virtual void setBackgroundColor(WebColor)  override { }
     virtual void setHasTransparentBackground(bool)  override { }
     virtual void setVisible(bool)  override { }
     virtual void setPageScaleFactorAndLimits(float pageScaleFactor, float minimum, float maximum)  override { }
     virtual void startPageScaleAnimation(const WebPoint& destination, bool useAnchor, float newPageScale, double durationSec)  override { }
     virtual void setNeedsAnimate()  override { }
     virtual bool commitRequested() const  override { return false; }
     virtual void finishAllRendering()  override { }
-    virtual void registerSelection(const WebSelectionBound& start, const WebSelectionBound& end) override
+    virtual void registerSelection(const WebSelectionBounds& bounds) override
     {
-        m_start = adoptPtr(new WebSelectionBound(start));
-        m_end = adoptPtr(new WebSelectionBound(end));
+        m_bounds = adoptPtr(new WebSelectionBounds(bounds));
     }
     virtual void clearSelection() override
     {
         m_selectionCleared = true;
-        m_start.clear();
-        m_end.clear();
+        m_bounds.clear();
     }
 
     bool getAndResetSelectionCleared()
     {
         bool selectionCleared  = m_selectionCleared;
         m_selectionCleared = false;
         return selectionCleared;
     }
 
-    const WebSelectionBound* start() const { return m_start.get(); }
-    const WebSelectionBound* end() const { return m_end.get(); }
+    const WebSelectionBounds* bounds() const { return m_bounds.get(); }
+    const WebSelectionBound* start() const { return m_bounds ? &m_bounds->start : nullptr; }
+    const WebSelectionBound* end() const { return m_bounds ? &m_bounds->end: nullptr; }
 
 private:
     bool m_selectionCleared;
-    OwnPtr<WebSelectionBound> m_start;
-    OwnPtr<WebSelectionBound> m_end;
+    OwnPtr<WebSelectionBounds> m_bounds;
 };
 
 class CompositedSelectionBoundsTestWebViewClient : public FrameTestHelpers::TestWebViewClient {
 public:
     virtual ~CompositedSelectionBoundsTestWebViewClient() { }
     virtual WebLayerTreeView* layerTreeView() override { return &m_testLayerTreeView; }
 
     CompositedSelectionBoundsTestLayerTreeView& selectionLayerTreeView() { return m_testLayerTreeView; }
 
 private:
@@ skipping 29 matching lines @@
             EXPECT_FALSE(selectStart);
             EXPECT_FALSE(selectEnd);
             return;
         }
 
         ASSERT_TRUE(selectStart);
         ASSERT_TRUE(selectEnd);
 
         ASSERT_TRUE((*result)->IsArray());
         v8::Array& expectedResult = *v8::Array::Cast(*result);
-        ASSERT_EQ(10u, expectedResult.Length());
+        ASSERT_GE(expectedResult.Length(), 10u);
 
         blink::Node* layerOwnerNodeForStart = blink::V8Node::toImplWithTypeCheck(v8::Isolate::GetCurrent(), expectedResult.Get(0));
         ASSERT_TRUE(layerOwnerNodeForStart);
         EXPECT_EQ(layerOwnerNodeForStart->layoutObject()->enclosingLayer()->enclosingLayerForPaintInvalidation()->graphicsLayerBacking()->platformLayer()->id(), selectStart->layerId);
         EXPECT_EQ(expectedResult.Get(1)->Int32Value(), selectStart->edgeTopInLayer.x);
         EXPECT_EQ(expectedResult.Get(2)->Int32Value(), selectStart->edgeTopInLayer.y);
         EXPECT_EQ(expectedResult.Get(3)->Int32Value(), selectStart->edgeBottomInLayer.x);
         EXPECT_EQ(expectedResult.Get(4)->Int32Value(), selectStart->edgeBottomInLayer.y);
 
         blink::Node* layerOwnerNodeForEnd = blink::V8Node::toImplWithTypeCheck(v8::Isolate::GetCurrent(), expectedResult.Get(5));
         ASSERT_TRUE(layerOwnerNodeForEnd);
         EXPECT_EQ(layerOwnerNodeForEnd->layoutObject()->enclosingLayer()->enclosingLayerForPaintInvalidation()->graphicsLayerBacking()->platformLayer()->id(), selectEnd->layerId);
         EXPECT_EQ(expectedResult.Get(6)->Int32Value(), selectEnd->edgeTopInLayer.x);
         EXPECT_EQ(expectedResult.Get(7)->Int32Value(), selectEnd->edgeTopInLayer.y);
         EXPECT_EQ(expectedResult.Get(8)->Int32Value(), selectEnd->edgeBottomInLayer.x);
         EXPECT_EQ(expectedResult.Get(9)->Int32Value(), selectEnd->edgeBottomInLayer.y);
+
+        if (expectedResult.Length() == 12) {
+            EXPECT_EQ(expectedResult.Get(10)->BooleanValue(), m_fakeSelectionLayerTreeView.bounds()->isEditable);
+            EXPECT_EQ(expectedResult.Get(11)->BooleanValue(), m_fakeSelectionLayerTreeView.bounds()->isEditableRegionEmpty);
+        }
     }
 
     void runTestWithMultipleFiles(const char* testFile, ...)
     {
         va_list auxFiles;
         va_start(auxFiles, testFile);
         while (const char* auxFile = va_arg(auxFiles, const char*))
             registerMockedHttpURLLoad(auxFile);
         va_end(auxFiles);
 
         runTest(testFile);
     }
 
     CompositedSelectionBoundsTestWebViewClient m_fakeSelectionWebViewClient;
     CompositedSelectionBoundsTestLayerTreeView& m_fakeSelectionLayerTreeView;
     FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 TEST_F(CompositedSelectionBoundsTest, None) { runTest("composited_selection_bounds_none.html"); }
 TEST_F(CompositedSelectionBoundsTest, Basic) { runTest("composited_selection_bounds_basic.html"); }
 TEST_F(CompositedSelectionBoundsTest, Transformed) { runTest("composited_selection_bounds_transformed.html"); }
 TEST_F(CompositedSelectionBoundsTest, SplitLayer) { runTest("composited_selection_bounds_split_layer.html"); }
 TEST_F(CompositedSelectionBoundsTest, EmptyLayer) { runTest("composited_selection_bounds_empty_layer.html"); }
 TEST_F(CompositedSelectionBoundsTest, Iframe) { runTestWithMultipleFiles("composited_selection_bounds_iframe.html", "composited_selection_bounds_basic.html", nullptr); }
 TEST_F(CompositedSelectionBoundsTest, DetachedFrame) { runTest("composited_selection_bounds_detached_frame.html"); }
+TEST_F(CompositedSelectionBoundsTest, Editable) { runTest("composited_selection_bounds_editable.html"); }
+TEST_F(CompositedSelectionBoundsTest, EmptyEditable) { runTest("composited_selection_bounds_empty_editable.html"); }
 
 
 TEST_F(WebFrameTest, CompositedSelectionBoundsCleared)
 {
     RuntimeEnabledFeatures::setCompositedSelectionUpdateEnabled(true);
 
     registerMockedHttpURLLoad("select_range_basic.html");
     registerMockedHttpURLLoad("select_range_scroll.html");
 
     int viewWidth = 500;
@@ skipping 2716 matching lines @@
     FrameTestHelpers::TestWebRemoteFrameClient remoteClient;
     WebView* view = WebView::create(&viewClient);
     view->setMainFrame(WebRemoteFrame::create(&remoteClient));
     FrameTestHelpers::TestWebRemoteFrameClient childFrameClient;
     WebRemoteFrame* childFrame = view->mainFrame()->toWebRemoteFrame()->createRemoteChild("", &childFrameClient);
     childFrame->detach();
     view->close();
 }
 
 } // namespace blink