[GRC] Process Coordination Unit support for Global Resource Controller

services/resource_coordinator/public/cpp/coordination_unit_id.h

 // Copyright 2017 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 SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_ID_H_
 #define SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_ID_H_
 
 #include <string>
 
 #include "services/resource_coordinator/public/cpp/coordination_unit_types.h"
 #include "services/resource_coordinator/public/cpp/resource_coordinator_export.h"
 
 namespace resource_coordinator {
 
 // This is a native struct rather than a mojom struct as we eventually want
 // to annotate base::TaskRunner with CUs for cost attribution purses and
 // would like to move it to base/ as easily as possible at that point.
 struct SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_EXPORT CoordinationUnitID {
   CoordinationUnitID();
   CoordinationUnitID(const CoordinationUnitType& type,
                      const std::string& new_id);
+  CoordinationUnitID(const CoordinationUnitType& type, uint64_t new_id);

[oystein (OOO til 10th of July), 2017/05/17 23:06:07]

Slight yak shave, sorry: Can you make the id type a typedef in this class,
rather than a hardcoded uint64_t? I suspect it may be something that may change
again later and something we'll potentially refer to in a lot of other places.

[matthalp, 2017/05/18 16:13:46]

Done, but with a caveat:

The most straight-forward typedef would have been CoordinationUnitI(d|D) which
would be consistent with the CoordinationUnitType. However, CoordinationUnitID
is the name of the class itself, so there is some ambiguity.

What I did (but am not especially fond of):

  typedef CoordinationUnitTypeId uint64_t

  This rationale is that id field is essentially uniquely identifying the CU of
the type. However reading that type could also be interpreted as the
CoordinationUnitType to the uninformed developer

More Pragramatic, but bigger yak shave:

  Change the CoordinationUnitID struct to CoordinationUnitUID (a
CoordinationUnit Unique Identifier) and then make the typedef
CoordinationUnitId. This is because the <type, id> together create a unique
identifier for an instance of CoordinationUnitImpl (and its derived classes)

[oystein (OOO til 10th of July), 2017/05/18 21:24:32]

Yep that makes sense to me, including the rename: Can you add a comment
regarding that, above the class? '// TODO(oysteine): Rename to
CoordinationUnitGUID to better differentiate the class from the internal id', or
something.

 
   bool operator==(const CoordinationUnitID& b) const {
     return id == b.id && type == b.type;
   }
 
   int64_t id;
   CoordinationUnitType type;
 };
 
 }  // resource_coordinator
 
 namespace std {
 
 template <>
 struct hash<resource_coordinator::CoordinationUnitID> {
   uint64_t operator()(
       const resource_coordinator::CoordinationUnitID& id) const {
     return ((static_cast<uint64_t>(id.type)) << 32) | id.id;
   }
 };
 
 }  // namespace std
 
 #endif  // SERVICES_RESOURCE_COORDINATOR_PUBLIC_CPP_ID_H_