[Sync] Relax EnumSet semantics for some functions

chrome/browser/sync/util/enum_set.h

 // Copyright (c) 2011 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 CHROME_BROWSER_SYNC_UTIL_ENUM_SET_H_
 #define CHROME_BROWSER_SYNC_UTIL_ENUM_SET_H_
 #pragma once
 
 #include <bitset>
 #include <cstddef>
@@ skipping 47 matching lines @@
   // Iterator is a forward-only read-only iterator for EnumSet.  Its
   // interface is deliberately distinct from an STL iterator as its
   // semantics are substantially different.
   //
   // Example usage:
   //
   // for (EnumSet<...>::Iterator it = enums.First(); it.Good(); it.Inc()) {
   //   Process(it.Get());
   // }
   //
-  // There are no guarantees as to what will happen if you modify an
-  // EnumSet while traversing it with an iterator.
+  // The iterator must not be outlived by the set.  In particular, the
+  // following is an error:
+  //
+  // EnumSet<...> SomeFn() { ... }
+  //
+  // /* ERROR */
+  // for (EnumSet<...>::Iterator it = SomeFun().First(); ...
+  //
+  // Also, there are no guarantees as to what will happen if you
+  // modify an EnumSet while traversing it with an iterator.
   class Iterator {
    public:
     // A default-constructed iterator can't do anything except check
     // Good().  You need to call First() on an EnumSet to get a usable
     // iterator.
     Iterator() : enums_(NULL), i_(kValueCount) {}
     ~Iterator() {}
 
     // Copy constructor and assignment welcome.
 
@@ skipping 61 matching lines @@
   }
 
   ~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 to our set.
+  // 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_;
   }
 
   // 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_;
   }
 
-  // Removes the given value from our set.
+  // If the given value is in range, removes it from our set.
   void Remove(E value) {
-    enums_.reset(ToIndex(value));
+    if (InRange(value)) {
+      enums_.reset(ToIndex(value));
+    }
   }
 
   // Removes all values in the given set from our set.
   void RemoveAll(EnumSet other) {
     enums_ &= ~other.enums_;
   }
 
   // Removes all values from our set.
   void Clear() {
     enums_.reset();
   }
 
-  // Returns true iff the given value is a member of our set.
+  // Returns true iff the given value is in range and a member of our
+  // set.
   bool Has(E value) const {
-    return enums_.test(ToIndex(value));
+    return InRange(value) && enums_.test(ToIndex(value));
   }
 
   // Returns true iff the given set is a subset of our set.
   bool HasAll(EnumSet other) const {
     return (enums_ & other.enums_) == other.enums_;
   }
 
   // Returns true iff our set and the given set contain exactly the
   // same values.
   bool Equals(const EnumSet& other) const {
@@ skipping 18 matching lines @@
  private:
   friend EnumSet Union<E, MinEnumValue, MaxEnumValue>(
       EnumSet set1, EnumSet set2);
   friend EnumSet Intersection<E, MinEnumValue, MaxEnumValue>(
       EnumSet set1, EnumSet set2);
   friend EnumSet Difference<E, MinEnumValue, MaxEnumValue>(
       EnumSet set1, EnumSet set2);
 
   explicit EnumSet(EnumBitSet enums) : enums_(enums) {}
 
+  static bool InRange(E value) {
+    return (value >= MinEnumValue) && (value <= MaxEnumValue);
+  }
+
   // Converts a value to/from an index into |enums_|.
 
   static size_t ToIndex(E value) {
     DCHECK_GE(value, MinEnumValue);
     DCHECK_LE(value, MaxEnumValue);
     return value - MinEnumValue;
   }
 
   static E FromIndex(size_t i) {
     DCHECK_LT(i, kValueCount);
@@ skipping 28 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 browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_UTIL_ENUM_SET_H_