SyscallIterator: support C++11 range-based for loops

sandbox/linux/seccomp-bpf/syscall_iterator.cc

Index: sandbox/linux/seccomp-bpf/syscall_iterator.cc
diff --git a/sandbox/linux/seccomp-bpf/syscall_iterator.cc b/sandbox/linux/seccomp-bpf/syscall_iterator.cc
index 6701d50d71f297b14a21c4c33abc6a0336482a9a..a129199eebbfa1f215a2b01cc17b8aa70a7cee7a 100644
--- a/sandbox/linux/seccomp-bpf/syscall_iterator.cc
+++ b/sandbox/linux/seccomp-bpf/syscall_iterator.cc
@@ -4,6 +4,7 @@
 
 #include "sandbox/linux/seccomp-bpf/syscall_iterator.h"
 
+#include "base/logging.h"
 #include "base/macros.h"
 #include "sandbox/linux/seccomp-bpf/linux_seccomp.h"
 
@@ -38,14 +39,16 @@ const SyscallRange kValidSyscallRanges[] = {
 #endif
 };
 
-uint32_t NextSyscall(uint32_t cur, bool invalid_only) {
+// NextSyscall returns the next system call in the specified system
+// call set after |cur|, or 0 if no such system call exists.
+uint32_t NextSyscall(uint32_t cur, SyscallSet set) {
   for (const SyscallRange& range : kValidSyscallRanges) {
     if (range.first > 0 && cur < range.first - 1) {
       return range.first - 1;
     }
     if (cur <= range.last) {
-      if (invalid_only && cur < range.last) {
-        return range.last;
+      if (set == SyscallSet::INVALID_ONLY) {
+        return range.last + 1;
       }
       return cur + 1;
     }
@@ -62,24 +65,42 @@ uint32_t NextSyscall(uint32_t cur, bool invalid_only) {
   if (cur < 0x80000000u)
     return 0x80000000u;
 
-  return 0xFFFFFFFFu;
+  if (cur < 0xFFFFFFFFu)
+    return 0xFFFFFFFFu;
+  return 0;
 }
 
 }  // namespace
 
-uint32_t SyscallIterator::Next() {
-  if (done_) {
-    return num_;
+SyscallIterator begin(SyscallSet set) {
+  return SyscallIterator(set, false);
+}
+
+SyscallIterator end(SyscallSet set) {
+  return SyscallIterator(set, true);
+}
+
+SyscallIterator::SyscallIterator(SyscallSet set, bool done)
+    : set_(set), done_(done), num_(0) {
+  if (set_ == SyscallSet::INVALID_ONLY && !done_ && IsValid(num_)) {
+    ++*this;
   }
+}
+
+uint32_t SyscallIterator::operator*() const {
+  DCHECK(!done_);
+  return num_;
+}
 
-  uint32_t val;
-  do {
-    val = num_;
-    num_ = NextSyscall(num_, invalid_only_);
-  } while (invalid_only_ && IsValid(val));
+SyscallIterator& SyscallIterator::operator++() {
+  DCHECK(!done_);
 
-  done_ |= val == 0xFFFFFFFFu;
-  return val;
+  num_ = NextSyscall(num_, set_);
+  if (num_ == 0) {
+    done_ = true;
+  }
+
+  return *this;
 }
 
 bool SyscallIterator::IsValid(uint32_t num) {
@@ -91,4 +112,13 @@ bool SyscallIterator::IsValid(uint32_t num) {
   return false;
 }
 
+bool operator==(const SyscallIterator& lhs, const SyscallIterator& rhs) {
+  DCHECK(lhs.set_ == rhs.set_);
+  return (lhs.done_ == rhs.done_) && (lhs.num_ == rhs.num_);
+}
+
+bool operator!=(const SyscallIterator& lhs, const SyscallIterator& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace sandbox