Avoid exposing cc::Layer tree to CompositorProxy

third_party/WebKit/Source/platform/graphics/CompositorMutatorClient.h

 // 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.
 
 #ifndef CompositorMutatorClient_h
 #define CompositorMutatorClient_h
 
+#include <map>
+#include <memory>
+#include <utility>
+
 #include "platform/PlatformExport.h"
+#include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/WebCompositorMutatorClient.h"
-#include <memory>
 
 namespace blink {
 
 class CompositorMutator;
 struct CompositorMutations;
 class CompositorMutationsTarget;
+class CompositorMutation;
 
 class PLATFORM_EXPORT CompositorMutatorClient
     : public WebCompositorMutatorClient {
  public:
   CompositorMutatorClient(CompositorMutator*, CompositorMutationsTarget*);
   virtual ~CompositorMutatorClient();
 
   void SetNeedsMutate();
+  void RegisterCompositorProxy(uint64_t proxy_id,
+                               uint64_t element_id,
+                               uint32_t mutable_properties);
+  void UnregisterCompositorProxy(uint64_t proxy_id);
 
   // cc::LayerTreeMutator
   bool Mutate(base::TimeTicks monotonic_time, cc::LayerTreeImpl*) override;
   void SetClient(cc::LayerTreeMutatorClient*) override;
   base::Closure TakeMutations() override;
 
   CompositorMutator* Mutator() { return mutator_.Get(); }
 
   void SetMutationsForTesting(std::unique_ptr<CompositorMutations>);
 
  private:
+  void SnapshotLayerTree(const cc::LayerTreeImpl*,
+                         ProxyCompositorMutablePropertiesMap*) const;
+  void UpdateLayerTree(cc::LayerTreeImpl*,
+                       uint64_t element_id,
+                       const CompositorMutation*);
+  void UpdateMutations(uint64_t element_id,
+                       std::unique_ptr<CompositorMutation>);
+
   cc::LayerTreeMutatorClient* client_;
   CompositorMutationsTarget* mutations_target_;
+  // Maps from a |CompositorProxy| id to a pair of the element id for that
+  // proxy, and the bitmask of properties the proxy is allowed to mutate.
+  std::map<uint64_t, std::pair<uint64_t, uint32_t>> input_properties_;
   // Accessed by main and compositor threads.
   CrossThreadPersistent<CompositorMutator> mutator_;
   std::unique_ptr<CompositorMutations> mutations_;
 };
 
 }  // namespace blink
 
 #endif  // CompositorMutatorClient_h