1 files changed, 57 insertions, 35 deletions

diff --git a/chromium/ui/compositor/layer.cc b/chromium/ui/compositor/layer.cc
index e6217f583f0..a869508f757 100644
--- a/chromium/ui/compositor/layer.cc
+++ b/chromium/ui/compositor/layer.cc
@@ -213,6 +213,9 @@ Layer::~Layer() {
 
   // Destroying the animator may cause observers to use the layer. Destroy the
   // animator first so that the layer is still around.
+#if defined(ADDRESS_SANITIZER)
+  destroyed_ = true;
+#endif
   SetAnimator(nullptr);
   if (compositor_)
     compositor_->SetRootLayer(nullptr);
@@ -229,7 +232,7 @@ Layer::~Layer() {
     content_layer_->ClearClient();
   cc_layer_->RemoveFromParent();
   if (transfer_release_callback_)
-    transfer_release_callback_->Run(gpu::SyncToken(), false);
+    std::move(transfer_release_callback_).Run(gpu::SyncToken(), false);
 
   ResetSubtreeReflectedLayer();
 }
@@ -296,8 +299,7 @@ std::unique_ptr<Layer> Layer::Mirror() {
     // freed up until the original layer releases it.
     mirror->SetTransferableResource(
         transfer_resource_,
-        viz::SingleReleaseCallback::Create(base::BindOnce(
-            [](const gpu::SyncToken& sync_token, bool is_lost) {})),
+        base::BindOnce([](const gpu::SyncToken& sync_token, bool is_lost) {}),
         frame_size_in_dip_);
   }
 
@@ -436,6 +438,9 @@ bool Layer::Contains(const Layer* other) const {
 }
 
 void Layer::SetAnimator(LayerAnimator* animator) {
+#if defined(ADDRESS_SANITIZER)
+  CHECK(!destroyed_ || !animator);
+#endif
   Compositor* compositor = GetCompositor();
 
   if (animator_) {
@@ -710,9 +715,22 @@ void Layer::SetIsFastRoundedCorner(bool enable) {
     mirror->dest()->SetIsFastRoundedCorner(enable);
 }
 
+bool Layer::GetTargetTransformRelativeTo(const Layer* ancestor,
+                                         gfx::Transform* transform) const {
+  return GetTransformRelativeToImpl(ancestor, /*is_target_transform=*/true,
+                                    transform);
+}
+
+bool Layer::GetTransformRelativeTo(const Layer* ancestor,
+                                   gfx::Transform* transform) const {
+  return GetTransformRelativeToImpl(ancestor, /*is_target_transform=*/false,
+                                    transform);
+}
+
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
+                                bool use_target_transform,
                                 gfx::PointF* point) {
   if (source == target)
     return;
@@ -721,25 +739,9 @@ void Layer::ConvertPointToLayer(const Layer* source,
   CHECK_EQ(root_layer, GetRoot(target));
 
   if (source != root_layer)
-    source->ConvertPointForAncestor(root_layer, point);
+    source->ConvertPointForAncestor(root_layer, use_target_transform, point);
   if (target != root_layer)
-    target->ConvertPointFromAncestor(root_layer, point);
-}
-
-bool Layer::GetTargetTransformRelativeTo(const Layer* ancestor,
-                                         gfx::Transform* transform) const {
-  const Layer* p = this;
-  for (; p && p != ancestor; p = p->parent()) {
-    gfx::Transform translation;
-    translation.Translate(static_cast<float>(p->bounds().x()),
-                          static_cast<float>(p->bounds().y()));
-    // Use target transform so that result will be correct once animation is
-    // finished.
-    if (!p->GetTargetTransform().IsIdentity())
-      transform->ConcatTransform(p->GetTargetTransform());
-    transform->ConcatTransform(translation);
-  }
-  return p == ancestor;
+    target->ConvertPointFromAncestor(root_layer, use_target_transform, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
@@ -921,10 +923,9 @@ bool Layer::ContainsMirrorForTest(Layer* mirror) const {
   return it != mirrors_.end();
 }
 
-void Layer::SetTransferableResource(
-    const viz::TransferableResource& resource,
-    std::unique_ptr<viz::SingleReleaseCallback> release_callback,
-    gfx::Size texture_size_in_dip) {
+void Layer::SetTransferableResource(const viz::TransferableResource& resource,
+                                    viz::ReleaseCallback release_callback,
+                                    gfx::Size texture_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
   DCHECK(!resource.mailbox_holder.mailbox.IsZero());
   DCHECK(release_callback);
@@ -942,7 +943,7 @@ void Layer::SetTransferableResource(
     frame_size_in_dip_ = gfx::Size();
   }
   if (transfer_release_callback_)
-    transfer_release_callback_->Run(gpu::SyncToken(), false);
+    std::move(transfer_release_callback_).Run(gpu::SyncToken(), false);
   transfer_release_callback_ = std::move(release_callback);
   transfer_resource_ = resource;
   SetTextureSize(texture_size_in_dip);
@@ -952,8 +953,7 @@ void Layer::SetTransferableResource(
     // should be able to release the texture resource.
     mirror->dest()->SetTransferableResource(
         transfer_resource_,
-        viz::SingleReleaseCallback::Create(base::BindOnce(
-            [](const gpu::SyncToken& sync_token, bool is_lost) {})),
+        base::BindOnce([](const gpu::SyncToken& sync_token, bool is_lost) {}),
         frame_size_in_dip_);
   }
 }
@@ -1062,8 +1062,7 @@ void Layer::SetShowSolidColorContent() {
 
   transfer_resource_ = viz::TransferableResource();
   if (transfer_release_callback_) {
-    transfer_release_callback_->Run(gpu::SyncToken(), false);
-    transfer_release_callback_.reset();
+    std::move(transfer_release_callback_).Run(gpu::SyncToken(), false);
   }
   RecomputeDrawsContentAndUVRect();
 
@@ -1336,7 +1335,7 @@ bool Layer::FillsBoundsCompletely() const { return fills_bounds_completely_; }
 bool Layer::PrepareTransferableResource(
     cc::SharedBitmapIdRegistrar* bitmap_registar,
     viz::TransferableResource* resource,
-    std::unique_ptr<viz::SingleReleaseCallback>* release_callback) {
+    viz::ReleaseCallback* release_callback) {
   if (!transfer_release_callback_)
     return false;
   *resource = transfer_resource_;
@@ -1377,9 +1376,12 @@ void Layer::StackRelativeTo(Layer* child, Layer* other, bool above) {
 }
 
 bool Layer::ConvertPointForAncestor(const Layer* ancestor,
+                                    bool use_target_transform,
                                     gfx::PointF* point) const {
   gfx::Transform transform;
-  bool result = GetTargetTransformRelativeTo(ancestor, &transform);
+  bool result = use_target_transform
+                    ? GetTargetTransformRelativeTo(ancestor, &transform)
+                    : GetTransformRelativeTo(ancestor, &transform);
   auto p = gfx::Point3F(*point);
   transform.TransformPoint(&p);
   *point = p.AsPointF();
@@ -1387,9 +1389,12 @@ bool Layer::ConvertPointForAncestor(const Layer* ancestor,
 }
 
 bool Layer::ConvertPointFromAncestor(const Layer* ancestor,
+                                     bool use_target_transform,
                                      gfx::PointF* point) const {
   gfx::Transform transform;
-  bool result = GetTargetTransformRelativeTo(ancestor, &transform);
+  bool result = use_target_transform
+                    ? GetTargetTransformRelativeTo(ancestor, &transform)
+                    : GetTransformRelativeTo(ancestor, &transform);
   auto p = gfx::Point3F(*point);
   transform.TransformPointReverse(&p);
   *point = p.AsPointF();
@@ -1564,12 +1569,12 @@ LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
   return compositor ? compositor->layer_animator_collection() : nullptr;
 }
 
-base::Optional<int> Layer::GetFrameNumber() const {
+absl::optional<int> Layer::GetFrameNumber() const {
   if (const Compositor* compositor = GetCompositor()) {
     return compositor->activated_frame_count();
   }
 
-  return base::nullopt;
+  return absl::nullopt;
 }
 
 float Layer::GetRefreshRate() const {
@@ -1718,4 +1723,21 @@ void Layer::SetFillsBoundsOpaquelyWithReason(bool fills_bounds_opaquely,
     delegate_->OnLayerFillsBoundsOpaquelyChanged(reason);
 }
 
+bool Layer::GetTransformRelativeToImpl(const Layer* ancestor,
+                                       bool is_target_transform,
+                                       gfx::Transform* transform) const {
+  const Layer* p = this;
+  for (; p && p != ancestor; p = p->parent()) {
+    gfx::Transform translation;
+    translation.Translate(static_cast<float>(p->bounds().x()),
+                          static_cast<float>(p->bounds().y()));
+    const gfx::Transform& layer_transform =
+        is_target_transform ? p->GetTargetTransform() : p->transform();
+    if (!layer_transform.IsIdentity())
+      transform->ConcatTransform(layer_transform);
+    transform->ConcatTransform(translation);
+  }
+  return p == ancestor;
+}
+
 }  // namespace ui