Use element id's for animations

third_party/WebKit/Source/platform/graphics/CompositorMutableStateTest.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/CompositorMutableState.h"
 
 #include "base/message_loop/message_loop.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "platform/graphics/CompositorElementId.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/CompositorMutableStateProvider.h"
 #include "platform/graphics/CompositorMutation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 using cc::FakeImplTaskRunnerProvider;
 using cc::FakeLayerTreeHostImpl;
@@ skipping 51 matching lines @@
     hostImpl().SetViewportSize(root->bounds());
     hostImpl().active_tree()->SetRootLayer(std::move(root));
     hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
     CompositorMutations mutations;
     CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
     OwnPtr<CompositorMutableState> state(provider.getMutableStateFor(42));
     EXPECT_FALSE(state);
 }
 
-TEST_F(CompositorMutableStateTest, MutableStateNoMutableProperties)
+TEST_F(CompositorMutableStateTest, EnsureNoSubElementIdCollisions)
 {
-    // In this test, there is a layer with an element id, but no mutable
-    // properties. This should behave just as if we'd had no element id.
-    std::unique_ptr<LayerImpl> root = LayerImpl::Create(hostImpl().active_tree(), 42);
-    SetLayerPropertiesForTesting(root.get());
-    root->SetElementId(42);
-
-    hostImpl().SetViewportSize(root->bounds());
-    hostImpl().active_tree()->SetRootLayer(std::move(root));
-    hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
-
-    CompositorMutations mutations;
-    CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
-    OwnPtr<CompositorMutableState> state(provider.getMutableStateFor(42));
-    EXPECT_FALSE(state);
+    // If we happen to do bit shifting in CompositorElementId, try to catch

[jbroman, 2016/06/06 14:23:20]

Is this test still meaningful with the current pair-of-ints implementation?

[Ian Vollick, 2016/06/06 16:31:29]

Not really. I'd put it in to catch a bug I'd caused earlier, but given that I've
switched to a pair of ints, it's so unlikely to repeat that I think this test is
just dead weight. Removed.

+    // cases where we forget to shift before bitwise or'ing.
+    const int domNodeId = 42;
+    CompositorElementId createdWithSubElement = createCompositorElementId(domNodeId, CompositorSubElementId::Scroll);
+    CompositorElementId createdDirectly(static_cast<uint64_t>(domNodeId) | static_cast<uint64_t>(CompositorSubElementId::Scroll), 0);
+    EXPECT_NE(createdWithSubElement, createdDirectly);
 }
 
 TEST_F(CompositorMutableStateTest, MutableStateMutableProperties)
 {
     // In this test, there is a layer with an element id and mutable properties.
     // In this case, we should get a valid mutable state for this element id that
     // has a real effect on the corresponding layer.
     std::unique_ptr<LayerImpl> root = LayerImpl::Create(hostImpl().active_tree(), 42);
 
     std::unique_ptr<LayerImpl> scopedLayer =
         LayerImpl::Create(hostImpl().active_tree(), 11);
     LayerImpl* layer = scopedLayer.get();
     layer->SetScrollClipLayer(root->id());
 
     root->AddChild(std::move(scopedLayer));
 
     SetLayerPropertiesForTesting(layer);
-    layer->SetElementId(12);
-    root->SetElementId(layer->element_id());
+
+    int primaryId = 12;
+    root->SetElementId(createCompositorElementId(primaryId, CompositorSubElementId::Primary));
+    layer->SetElementId(createCompositorElementId(primaryId, CompositorSubElementId::Scroll));
 
     root->SetMutableProperties(CompositorMutableProperty::kOpacity | CompositorMutableProperty::kTransform);
     layer->SetMutableProperties(CompositorMutableProperty::kScrollLeft | CompositorMutableProperty::kScrollTop);
 
     hostImpl().SetViewportSize(layer->bounds());
     hostImpl().active_tree()->SetRootLayer(std::move(root));
     hostImpl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
     CompositorMutations mutations;
     CompositorMutableStateProvider provider(hostImpl().active_tree(), &mutations);
 
-    OwnPtr<CompositorMutableState> state(provider.getMutableStateFor(layer->element_id()));
+    OwnPtr<CompositorMutableState> state(provider.getMutableStateFor(primaryId));
     EXPECT_TRUE(state.get());
 
     EXPECT_EQ(1.0, rootLayer()->Opacity());
     EXPECT_EQ(gfx::Transform().ToString(), rootLayer()->transform().ToString());
     EXPECT_EQ(0.0, layer->CurrentScrollOffset().x());
     EXPECT_EQ(0.0, layer->CurrentScrollOffset().y());
 
     gfx::Transform zero(0, 0, 0, 0, 0, 0);
     state->setOpacity(0.5);
     state->setTransform(zero.matrix());
     state->setScrollLeft(1.0);
     state->setScrollTop(1.0);
 
     EXPECT_EQ(0.5, rootLayer()->Opacity());
     EXPECT_EQ(zero.ToString(), rootLayer()->transform().ToString());
     EXPECT_EQ(1.0, layer->CurrentScrollOffset().x());
     EXPECT_EQ(1.0, layer->CurrentScrollOffset().y());
 
     // The corresponding mutation should reflect the changed values.
     EXPECT_EQ(1ul, mutations.map.size());
 
-    const CompositorMutation& mutation = *mutations.map.find(layer->element_id())->value;
+    const CompositorMutation& mutation = *mutations.map.find(primaryId)->value;
     EXPECT_TRUE(mutation.isOpacityMutated());
     EXPECT_TRUE(mutation.isTransformMutated());
     EXPECT_TRUE(mutation.isScrollLeftMutated());
     EXPECT_TRUE(mutation.isScrollTopMutated());
 
     EXPECT_EQ(0.5, mutation.opacity());
     EXPECT_EQ(zero.ToString(), gfx::Transform(mutation.transform()).ToString());
     EXPECT_EQ(1.0, mutation.scrollLeft());
     EXPECT_EQ(1.0, mutation.scrollTop());
 }
 
 } // namespace blink