[Sync] Clean up ModelType code.

components/sync/base/enum_set.h

 // Copyright (c) 2012 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 COMPONENTS_SYNC_BASE_ENUM_SET_H_
 #define COMPONENTS_SYNC_BASE_ENUM_SET_H_
 
 #include <bitset>
 #include <cstddef>
 #include <string>
@@ skipping 99 matching lines @@
       while ((i < kValueCount) && !enums_->test(i)) {
         ++i;
       }
       return i;
     }
 
     const EnumBitSet* enums_;
     size_t i_;
   };
 
-  // You can construct an EnumSet with 0, 1, 2, or 3 initial values.
-
   EnumSet() {}
 
-  explicit EnumSet(E value) { Put(value); }
-
-  EnumSet(E value1, E value2) {
-    Put(value1);
-    Put(value2);
-  }
-
-  EnumSet(E value1, E value2, E value3) {
-    Put(value1);
-    Put(value2);
-    Put(value3);
+  // Recursively chain constructors. Base case is the empty pack.
+  template <class... T>
+  EnumSet(E head, T... tail) : EnumSet(tail...) {
+    Put(head);
   }
 
   // Returns an EnumSet with all possible values.
   static EnumSet All() {
     EnumBitSet enums;
     enums.set();
     return EnumSet(enums);
   }
 
+  // Returns an EnumSet with all the values from start to end, inclusive.
+  static EnumSet FromRange(E start, E end) {
+    EnumSet set;
+    set.PutRange(start, end);
+    return set;
+  }
+
   ~EnumSet() {}
 
   // Copy constructor and assignment welcome.
 
   // Set operations.  Put, Retain, and Remove are basically
   // self-mutating versions of Union, Intersection, and Difference
   // (defined below).
 
   // Adds the given value (which must be in range) to our set.
   void Put(E value) { enums_.set(ToIndex(value)); }
 
   // Adds all values in the given set to our set.
   void PutAll(EnumSet other) { enums_ |= other.enums_; }
 
+  // Adds all values in the given range to our set, inclusive.
+  void PutRange(E start, E end) {
+    size_t endIndexInclusive = ToIndex(end);
+    DCHECK_LE(ToIndex(start), endIndexInclusive);
+    for (size_t current = ToIndex(start); current <= endIndexInclusive;
+         ++current) {
+      enums_.set(current);
+    }
+  }
+
   // There's no real need for a Retain(E) member function.
 
   // Removes all values not in the given set from our set.
   void RetainAll(EnumSet other) { enums_ &= other.enums_; }
 
   // If the given value is in range, removes it from our set.
   void Remove(E value) {
     if (InRange(value)) {
       enums_.reset(ToIndex(value));
     }
@@ skipping 86 matching lines @@
 
 template <typename E, E Min, E Max>
 EnumSet<E, Min, Max> Difference(EnumSet<E, Min, Max> set1,
                                 EnumSet<E, Min, Max> set2) {
   return EnumSet<E, Min, Max>(set1.enums_ & ~set2.enums_);
 }
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_ENUM_SET_H_