Introducing gpu::CommandBufferId as a distinct, IdType<...>-based type.

base/id_type.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 CONTENT_COMMON_ID_TYPE_H_
-#define CONTENT_COMMON_ID_TYPE_H_
+#ifndef BASE_ID_TYPE_H_
+#define BASE_ID_TYPE_H_
 
 #include <stdint.h>
 #include <cstddef>
 #include <ostream>
 #include <type_traits>
 
 // IdType32<>, IdType64<>, etc. wrap an integer id in a custom, type-safe type.
 //
 // IdType32<Foo> is an alternative to int, for a class Foo with methods like:
 //
 //    int GetId() { return id_; };
 //    static Foo* FromId(int id) { return g_all_foos_by_id[id]; }
 //
 // Such methods are a standard means of safely referring to objects across
 // thread and process boundaries.  But if a nearby class Bar also represents
 // its IDs as a bare int, horrific mixups are possible -- one example, of many,
 // is http://crrev.com/365437.  IdType<> offers compile-time protection against
 // such mishaps, since IdType32<Foo> is incompatible with IdType32<Bar>, even
 // though both just compile down to an int32_t.
 //
 // Templates in this file:
 //   IdType32<T> / IdTypeU32<T>: Signed / unsigned 32-bit IDs
 //   IdType64<T> / IdTypeU64<T>: Signed / unsigned 64-bit IDs
 //   IdType<>: For when you need a different underlying type or
-//             a default/invalid value other than zero.
+//             a default/null value other than zero.
 //
 // IdType32<Foo> behaves just like an int32_t in the following aspects:
 // - it can be used as a key in std::map and/or std::unordered_map;
 // - it can be used as an argument to DCHECK_EQ or streamed to LOG(ERROR);
 // - it has the same memory footprint and runtime overhead as int32_t;
 // - it can be copied by memcpy.
 //
 // IdType32<Foo> has the following differences from a bare int32_t:
 // - it forces coercions to go through GetUnsafeValue and FromUnsafeValue;
 // - it restricts the set of available operations (i.e. no multiplication);
 // - it ensures initialization to zero and allows checking against
 //   default-initialized values via is_null method.
 
-namespace content {
+namespace base {
 
 template <typename TypeMarker, typename WrappedType, WrappedType kInvalidValue>
 class IdType {
  public:
   IdType() : value_(kInvalidValue) {}
   bool is_null() const { return value_ == kInvalidValue; }
 
   static IdType FromUnsafeValue(WrappedType value) { return IdType(value); }
   WrappedType GetUnsafeValue() const { return value_; }
 
@@ skipping 39 matching lines @@
 template <typename TypeMarker>
 using IdTypeU64 = IdType<TypeMarker, uint64_t, 0>;
 
 template <typename TypeMarker, typename WrappedType, WrappedType kInvalidValue>
 std::ostream& operator<<(
     std::ostream& stream,
     const IdType<TypeMarker, WrappedType, kInvalidValue>& id) {
   return stream << id.GetUnsafeValue();
 }
 
-}  // namespace content
+}  // namespace base
 
 #endif  // CONTENT_COMMON_ID_TYPE_H_