Change cc::ElementId to be a uint64_t

cc/trees/element_id.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 CC_TREES_ELEMENT_ID_H_
 #define CC_TREES_ELEMENT_ID_H_
 
 #include <stddef.h>
 
 #include <cstdint>
 #include <functional>
 #include <iosfwd>
 #include <memory>
 
 #include "base/hash.h"
 #include "cc/cc_export.h"
 
 namespace base {
 class Value;
 namespace trace_event {
 class TracedValue;
 }  // namespace trace_event
 }  // namespace base
 
 namespace cc {
 
+using ElementIdType = uint64_t;
+
+static const ElementIdType kInvalidElementId = 0;
+
 // Element ids are chosen by cc's clients and can be used as a stable identifier
 // across updates.
 //
 // Historically, the layer tree stored all compositing data but this has been
 // refactored over time into auxilliary structures such as property trees.
 //
 // In composited scrolling, Layers directly reference scroll tree nodes
 // (Layer::scroll_tree_index) but scroll tree nodes are being refactored to
 // reference stable element ids instead of layers. Scroll property nodes have
 // unique element ids that blink creates from scrollable areas (though this is
 // opaque to the compositor). This refactoring of scroll nodes keeping a
 // scrolling element id instead of a scrolling layer id allows for more general
 // compositing where, for example, multiple layers scroll with one scroll node.
 //
 // The animation system (see: ElementAnimations and blink::ElementAnimations) is
 // another auxilliary structure to the layer tree and uses element ids as a
 // stable identifier for animation targets. A Layer's element id can change over
 // the Layer's lifetime because non-default ElementIds are only set during an
 // animation's lifetime.
 struct CC_EXPORT ElementId {
-  ElementId(int primaryId, int secondaryId)
-      : primaryId(primaryId), secondaryId(secondaryId) {}
-  ElementId() : ElementId(0, 0) {}
+  explicit ElementId(int id) : id_(id) {}
+  ElementId() : ElementId(kInvalidElementId) {}
 
   bool operator==(const ElementId& o) const;
   bool operator!=(const ElementId& o) const;
   bool operator<(const ElementId& o) const;
 
   // An ElementId's conversion to a boolean value depends only on its primaryId.
   explicit operator bool() const;
 
   void AddToTracedValue(base::trace_event::TracedValue* res) const;
   std::unique_ptr<base::Value> AsValue() const;
 
   // The compositor treats this as an opaque handle and should not know how to
   // interpret these bits. Non-blink cc clients typically operate in terms of
   // layers and may set this value to match the client's layer id.
-  int primaryId;
-  int secondaryId;
+  ElementIdType id_;

[wkorman, 2017/05/08 22:25:26]

For the record: we discussed in person re: making this a class rather than a
struct and having this be private. Could pursue subsequently. Only a couple of
areas in Blink read this directly currently (to output as string, and to
retrieve id we know we stuck in in the first place to pull off sub id).

Alternatives discussed trade off data hiding improvements at cost of more code
complexity or performance overhead or both. So leaving as it is seems ok for
now.

To some extent the '_' suffix should make it clear that one shouldn't monkey
with this unless one knows what one is doing.

 };
 
-CC_EXPORT ElementId LayerIdToElementIdForTesting(int layer_id);
+ElementId CC_EXPORT LayerIdToElementIdForTesting(int layer_id);
 
 struct CC_EXPORT ElementIdHash {
   size_t operator()(ElementId key) const;
 };
 
 // Stream operator so ElementId can be used in assertion statements.
 CC_EXPORT std::ostream& operator<<(std::ostream& out, const ElementId& id);
 
 }  // namespace cc
 
 #endif  // CC_TREES_ELEMENT_ID_H_