Don't expose a LayerImpl reference to CompositorProxy.

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

Index: third_party/WebKit/Source/platform/graphics/CompositorMutableState.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/CompositorMutableState.cpp b/third_party/WebKit/Source/platform/graphics/CompositorMutableState.cpp
index 87c1ea20661c2dfbf718f444623743a0a1b67b24..250678c5173a0efdf51a257fa9ae4709e69297bc 100644
--- a/third_party/WebKit/Source/platform/graphics/CompositorMutableState.cpp
+++ b/third_party/WebKit/Source/platform/graphics/CompositorMutableState.cpp
@@ -4,79 +4,50 @@
 
 #include "platform/graphics/CompositorMutableState.h"
 
-#include "cc/layers/layer_impl.h"
-#include "cc/trees/layer_tree_impl.h"
+#include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/CompositorMutation.h"
 
 namespace blink {
-CompositorMutableState::CompositorMutableState(CompositorMutation* mutation,
-                                               cc::LayerImpl* main,
-                                               cc::LayerImpl* scroll)
-    : m_mutation(mutation), m_mainLayer(main), m_scrollLayer(scroll) {}
+CompositorMutableState::CompositorMutableState(
+    CompositorMutation* mutation,
+    CompositorMutableProperties* properties)
+    : m_mutation(mutation), m_properties(properties) {}
 
 CompositorMutableState::~CompositorMutableState() {}
 
 double CompositorMutableState::opacity() const {
-  return m_mainLayer->Opacity();
+  return m_properties->opacity;
 }
 
 void CompositorMutableState::setOpacity(double opacity) {
-  if (!m_mainLayer)
-    return;
-  m_mainLayer->layer_tree_impl()
-      ->property_trees()
-      ->effect_tree.OnOpacityAnimated(opacity, m_mainLayer->effect_tree_index(),
-                                      m_mainLayer->layer_tree_impl());
+  m_properties->opacity = opacity;

[smcgruer, 2017/03/20 14:31:50]

I may be thinking about this incorrectly, but I believe this CL still changes
the code behavior when there are multiple CompositorProxy objects for the same
element.

Previously, all CompositorProxy objects for the same element would share not
only the same CompositorMutation*, but also the same cc::LayerImpl for
main/scroll. Therefore, if proxy A updated the opacity and then proxy B read it,
proxy B would get the value written by A.

With this CL, each CompositorProxy object for the same element shares only the
CompositorMutation*, and has a unique CompositorMutableProperties object that is
snapshotted at the beginning of the Mutate() call-chain. In this scenario, any
updates from proxy A to the elements opacity would not be seen by proxy B.
Correct?

This behavior change might be fine, I just want to make sure that we are aware
it is happening (if my interpretation of the code is correct :))

[Scott Funkenhauser, 2017/03/21 19:31:11]

Yes your interpretation is correct.

Since it was easier to isolate input between different proxies, and that's the
direction we want to move to eventually, I didn't think it made sense to retain
the same code behavior.

   m_mutation->setOpacity(opacity);
 }
 
 const SkMatrix44& CompositorMutableState::transform() const {
-  return m_mainLayer ? m_mainLayer->Transform().matrix() : SkMatrix44::I();
+  return m_properties->transform;
 }
 
 void CompositorMutableState::setTransform(const SkMatrix44& matrix) {
-  if (!m_mainLayer)
-    return;
-  m_mainLayer->layer_tree_impl()
-      ->property_trees()
-      ->transform_tree.OnTransformAnimated(gfx::Transform(matrix),
-                                           m_mainLayer->transform_tree_index(),
-                                           m_mainLayer->layer_tree_impl());
+  m_properties->transform = matrix;
   m_mutation->setTransform(matrix);
 }
 
 float CompositorMutableState::scrollLeft() const {
-  return m_scrollLayer ? m_scrollLayer->CurrentScrollOffset().x() : 0.0;
+  return m_properties->scrollLeft;
 }
 
 void CompositorMutableState::setScrollLeft(float scrollLeft) {
-  if (!m_scrollLayer)
-    return;
-
-  gfx::ScrollOffset offset = m_scrollLayer->CurrentScrollOffset();
-  offset.set_x(scrollLeft);
-  m_scrollLayer->layer_tree_impl()
-      ->property_trees()
-      ->scroll_tree.OnScrollOffsetAnimated(
-          m_scrollLayer->id(), m_scrollLayer->scroll_tree_index(), offset,
-          m_scrollLayer->layer_tree_impl());
+  m_properties->scrollLeft = scrollLeft;
   m_mutation->setScrollLeft(scrollLeft);
 }
 
 float CompositorMutableState::scrollTop() const {
-  return m_scrollLayer ? m_scrollLayer->CurrentScrollOffset().y() : 0.0;
+  return m_properties->scrollTop;
 }
 
 void CompositorMutableState::setScrollTop(float scrollTop) {
-  if (!m_scrollLayer)
-    return;
-  gfx::ScrollOffset offset = m_scrollLayer->CurrentScrollOffset();
-  offset.set_y(scrollTop);
-  m_scrollLayer->layer_tree_impl()
-      ->property_trees()
-      ->scroll_tree.OnScrollOffsetAnimated(
-          m_scrollLayer->id(), m_scrollLayer->scroll_tree_index(), offset,
-          m_scrollLayer->layer_tree_impl());
+  m_properties->scrollTop = scrollTop;
   m_mutation->setScrollTop(scrollTop);
 }