Backed out 2 changesets (bug 1734506, bug 1734502) for causing build bustages. CLOSED TREE

Backed out changeset 542b8b4e17ca (bug 1734506)
Backed out changeset b37746f292da (bug 1734502)

gfx/layers/AnimationInfo.cpp

@@ -122,6 +122,10 @@ bool AnimationInfo::StartPendingAnimations(const TimeStamp& aReadyTime) {
 }
 
 void AnimationInfo::TransferMutatedFlagToLayer(Layer* aLayer) {
+  if (mMutated) {
+    aLayer->Mutated();
+    mMutated = false;
+  }
 }
 
 bool AnimationInfo::ApplyPendingUpdatesForThisTransaction() {

gfx/layers/LayerManager.cpp

@@ -64,6 +64,7 @@ LayerManager::~LayerManager() = default;
 void LayerManager::Destroy() {
   mDestroyed = true;
   mUserData.Destroy();
+  mRoot = nullptr;
   mPartialPrerenderedAnimations.Clear();
 }
 

gfx/layers/LayerManager.h

@@ -58,6 +58,7 @@ namespace layers {
 class AsyncPanZoomController;
 class ClientLayerManager;
 class Layer;
+class ContainerLayer;
 class CompositorBridgeChild;
 class ReadbackProcessor;
 class FocusTarget;
@@ -198,7 +199,7 @@ class LayerManager : public WindowRenderer {
   /**
    * Can be called anytime
    */
-  Layer* GetRoot() { return nullptr; }
+  Layer* GetRoot() { return mRoot; }
 
   /**
    * CONSTRUCTION PHASE ONLY
@@ -209,6 +210,11 @@ class LayerManager : public WindowRenderer {
   virtual void Mutated(Layer* aLayer) {}
   virtual void MutatedSimple(Layer* aLayer) {}
 
+  /**
+   * CONSTRUCTION PHASE ONLY
+   * Create a ContainerLayer for this manager's layer tree.
+   */
+  virtual already_AddRefed<ContainerLayer> CreateContainerLayer() = 0;
   /**
    * Can be called anytime, from any thread.
    *
@@ -379,6 +385,7 @@ class LayerManager : public WindowRenderer {
   void SetContainsSVG(bool aContainsSVG) { mContainsSVG = aContainsSVG; }
 
  protected:
+  RefPtr<Layer> mRoot;
   gfx::UserData mUserData;
   bool mDestroyed;
   bool mSnapEffectiveTransforms;

gfx/layers/ipc/CompositorBridgeParent.cpp

@@ -1495,6 +1495,7 @@ ScopedLayerTreeRegistration::ScopedLayerTreeRegistration(
     : mLayersId(aLayersId) {
   EnsureLayerTreeMapReady();
   MonitorAutoLock lock(*sIndirectLayerTreesLock);
+  sIndirectLayerTrees[aLayersId].mRoot = nullptr;
   sIndirectLayerTrees[aLayersId].mController = aController;
 }
 

gfx/layers/ipc/CompositorBridgeParent.h

@@ -479,6 +479,7 @@ class CompositorBridgeParent final : public CompositorBridgeParentBase,
   struct LayerTreeState {
     LayerTreeState();
     ~LayerTreeState();
+    RefPtr<Layer> mRoot;
     RefPtr<GeckoContentController> mController;
     APZCTreeManagerParent* mApzcTreeManagerParent;
     RefPtr<CompositorBridgeParent> mParent;

gfx/tests/gtest/TestLayers.cpp

@@ -14,6 +14,21 @@ using namespace mozilla;
 using namespace mozilla::gfx;
 using namespace mozilla::layers;
 
+class TestContainerLayer : public ContainerLayer {
+ public:
+  explicit TestContainerLayer(LayerManager* aManager)
+      : ContainerLayer(aManager, nullptr) {}
+
+  virtual const char* Name() const { return "TestContainerLayer"; }
+
+  virtual LayerType GetType() const { return TYPE_CONTAINER; }
+
+  virtual void ComputeEffectiveTransforms(
+      const Matrix4x4& aTransformToSurface) {
+    DefaultComputeEffectiveTransforms(aTransformToSurface);
+  }
+};
+
 class TestLayerManager : public LayerManager {
  public:
   TestLayerManager() : LayerManager() {}
@@ -21,6 +36,10 @@ class TestLayerManager : public LayerManager {
   virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) {
     return false;
   }
+  virtual already_AddRefed<ContainerLayer> CreateContainerLayer() {
+    RefPtr<ContainerLayer> layer = new TestContainerLayer(this);
+    return layer.forget();
+  }
   virtual void GetBackendName(nsAString& aName) {}
   virtual LayersBackend GetBackendType() { return LayersBackend::LAYERS_BASIC; }
   virtual bool BeginTransaction(const nsCString& = nsCString()) { return true; }
@@ -37,3 +56,68 @@ class TestUserData : public LayerUserData {
   MOCK_METHOD0(Die, void());
   virtual ~TestUserData() { Die(); }
 };
+
+TEST(Layers, LayerConstructor)
+{ TestContainerLayer layer(nullptr); }
+
+TEST(Layers, Defaults)
+{
+  TestContainerLayer layer(nullptr);
+  ASSERT_EQ(1.0, layer.GetOpacity());
+  ASSERT_EQ(1.0f, layer.GetPostXScale());
+  ASSERT_EQ(1.0f, layer.GetPostYScale());
+
+  ASSERT_EQ(nullptr, layer.GetNextSibling());
+  ASSERT_EQ(nullptr, layer.GetPrevSibling());
+  ASSERT_EQ(nullptr, layer.GetFirstChild());
+  ASSERT_EQ(nullptr, layer.GetLastChild());
+}
+
+TEST(Layers, Transform)
+{
+  TestContainerLayer layer(nullptr);
+
+  Matrix4x4 identity;
+  ASSERT_EQ(true, identity.IsIdentity());
+
+  ASSERT_EQ(identity, layer.GetTransform());
+}
+
+TEST(Layers, UserData)
+{
+  UniquePtr<TestContainerLayer> layerPtr(new TestContainerLayer(nullptr));
+  TestContainerLayer& layer = *layerPtr;
+
+  void* key1 = (void*)1;
+  void* key2 = (void*)2;
+  void* key3 = (void*)3;
+
+  ASSERT_EQ(nullptr, layer.GetUserData(key1));
+  ASSERT_EQ(nullptr, layer.GetUserData(key2));
+  ASSERT_EQ(nullptr, layer.GetUserData(key3));
+
+  TestUserData* data1 = new TestUserData;
+  TestUserData* data2 = new TestUserData;
+  TestUserData* data3 = new TestUserData;
+
+  layer.SetUserData(key1, data1);
+  layer.SetUserData(key2, data2);
+  layer.SetUserData(key3, data3);
+
+  // Also checking that the user data is returned but not free'd
+  UniquePtr<LayerUserData> d1(layer.RemoveUserData(key1));
+  UniquePtr<LayerUserData> d2(layer.RemoveUserData(key2));
+  UniquePtr<LayerUserData> d3(layer.RemoveUserData(key3));
+  ASSERT_EQ(data1, d1.get());
+  ASSERT_EQ(data2, d2.get());
+  ASSERT_EQ(data3, d3.get());
+
+  layer.SetUserData(key1, d1.release());
+  layer.SetUserData(key2, d2.release());
+  layer.SetUserData(key3, d3.release());
+
+  // Layer has ownership of data1-3, check that they are destroyed
+  EXPECT_CALL(*data1, Die());
+  EXPECT_CALL(*data2, Die());
+  EXPECT_CALL(*data3, Die());
+}

layout/base/nsLayoutUtils.cpp

@@ -8970,6 +8970,23 @@ Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
   return Nothing();
 }
 
+/* static */
+bool nsLayoutUtils::ContainsMetricsWithId(const Layer* aLayer,
+                                          const ViewID& aScrollId) {
+  for (uint32_t i = aLayer->GetScrollMetadataCount(); i > 0; i--) {
+    if (aLayer->GetFrameMetrics(i - 1).GetScrollId() == aScrollId) {
+      return true;
+    }
+  }
+  for (Layer* child = aLayer->GetFirstChild(); child;
+       child = child->GetNextSibling()) {
+    if (ContainsMetricsWithId(child, aScrollId)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /* static */
 StyleTouchAction nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame) {
   if (!aFrame) {

layout/base/nsLayoutUtils.h

@@ -2794,6 +2794,13 @@ class nsLayoutUtils {
   static nsMargin ScrollbarAreaToExcludeFromCompositionBoundsFor(
       const nsIFrame* aScrollFrame);
 
+  /**
+   * Looks in the layer subtree rooted at aLayer for a metrics with scroll id
+   * aScrollId. Returns true if such is found.
+   */
+  static bool ContainsMetricsWithId(const Layer* aLayer,
+                                    const ViewID& aScrollId);
+
   static bool ShouldUseNoScriptSheet(mozilla::dom::Document*);
   static bool ShouldUseNoFramesSheet(mozilla::dom::Document*);
 

layout/painting/nsDisplayList.cpp

@@ -2074,6 +2074,21 @@ WebRenderLayerManager* nsDisplayListBuilder::GetWidgetLayerManager(
   return nullptr;
 }
 
+// Find the layer which should house the root scroll metadata for a given
+// layer tree. This is the async zoom container layer if there is one,
+// otherwise it's the root layer.
+Layer* GetLayerForRootMetadata(Layer* aRootLayer,
+                               ScrollableLayerGuid::ViewID aRootScrollId) {
+  Layer* asyncZoomContainer = DepthFirstSearch<ForwardIterator>(
+      aRootLayer, [aRootScrollId](Layer* aLayer) {
+        if (auto id = aLayer->GetAsyncZoomContainerId()) {
+          return *id == aRootScrollId;
+        }
+        return false;
+      });
+  return asyncZoomContainer ? asyncZoomContainer : aRootLayer;
+}
+
 void nsDisplayList::Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx,
                           int32_t aAppUnitsPerDevPixel) {
   FlattenedDisplayListIterator iter(aBuilder, this);