SERVER-44968 Remove useless BSONVersion enum class

7 files changed, 37 insertions, 49 deletions

diff --git a/src/mongo/bson/bson_validate.cpp b/src/mongo/bson/bson_validate.cpp
index 3a7a9bf728e..0cde1abe151 100644
--- a/src/mongo/bson/bson_validate.cpp
+++ b/src/mongo/bson/bson_validate.cpp
@@ -70,8 +70,8 @@ MONGO_COMPILER_NOINLINE Status makeError(StringData baseMsg,
 
 class Buffer {
 public:
-    Buffer(const char* buffer, uint64_t maxLength, BSONVersion version)
-        : _buffer(buffer), _position(0), _maxLength(maxLength), _version(version) {}
+    Buffer(const char* buffer, uint64_t maxLength)
+        : _buffer(buffer), _position(0), _maxLength(maxLength) {}
 
     template <typename N>
     bool readNumber(N* out) {
@@ -149,10 +149,6 @@ public:
         return _buffer;
     }
 
-    BSONVersion version() const {
-        return _version;
-    }
-
     /**
      * WARNING: only pass in a non-EOO idElem if it has been fully validated already!
      */
@@ -165,7 +161,6 @@ private:
     uint64_t _position;
     uint64_t _maxLength;
     BSONElement _idElem;
-    BSONVersion _version;
 };
 
 struct ValidationState {
@@ -417,12 +412,12 @@ Status validateBSONIterative(Buffer* buffer) {
 
 }  // namespace
 
-Status validateBSON(const char* originalBuffer, uint64_t maxLength, BSONVersion version) {
+Status validateBSON(const char* originalBuffer, uint64_t maxLength) {
     if (maxLength < 5) {
         return Status(ErrorCodes::InvalidBSON, "bson data has to be at least 5 bytes");
     }
 
-    Buffer buf(originalBuffer, maxLength, version);
+    Buffer buf(originalBuffer, maxLength);
     return validateBSONIterative(&buf);
 }
 
diff --git a/src/mongo/bson/bson_validate.h b/src/mongo/bson/bson_validate.h
index 13892ff80ab..4644ab361c4 100644
--- a/src/mongo/bson/bson_validate.h
+++ b/src/mongo/bson/bson_validate.h
@@ -42,8 +42,7 @@ class Status;
  * @param buf - bson data
  * @param maxLength - maxLength of buffer
  *                    this is NOT the bson size, but how far we know the buffer is valid
- * @param version - newest version to accept
  */
-Status validateBSON(const char* buf, uint64_t maxLength, BSONVersion version);
+Status validateBSON(const char* buf, uint64_t maxLength);
 
 }  // namespace mongo
diff --git a/src/mongo/bson/bson_validate_fuzzer.cpp b/src/mongo/bson/bson_validate_fuzzer.cpp
index 074c7b1682b..9ee05dbf29a 100644
--- a/src/mongo/bson/bson_validate_fuzzer.cpp
+++ b/src/mongo/bson/bson_validate_fuzzer.cpp
@@ -30,6 +30,6 @@
 #include "mongo/bson/bson_validate.h"
 
 extern "C" int LLVMFuzzerTestOneInput(const char* Data, size_t Size) {
-    mongo::Status ret = mongo::validateBSON(Data, Size, mongo::BSONVersion::kLatest);
+    mongo::Status ret = mongo::validateBSON(Data, Size);
     return 0;
 }
diff --git a/src/mongo/bson/bson_validate_test.cpp b/src/mongo/bson/bson_validate_test.cpp
index a07ae0b928d..a7fede6dada 100644
--- a/src/mongo/bson/bson_validate_test.cpp
+++ b/src/mongo/bson/bson_validate_test.cpp
@@ -54,10 +54,10 @@ void appendInvalidStringElement(const char* fieldName, BufBuilder* bb) {
 
 TEST(BSONValidate, Basic) {
     BSONObj x;
-    ASSERT_TRUE(x.valid(BSONVersion::kLatest));
+    ASSERT_TRUE(x.valid());
 
     x = BSON("x" << 1);
-    ASSERT_TRUE(x.valid(BSONVersion::kLatest));
+    ASSERT_TRUE(x.valid());
 }
 
 TEST(BSONValidate, RandomData) {
@@ -83,12 +83,12 @@ TEST(BSONValidate, RandomData) {
 
         ASSERT_EQUALS(size, o.objsize());
 
-        if (o.valid(BSONVersion::kLatest)) {
+        if (o.valid()) {
             numValid++;
             jsonSize += o.jsonString().size();
-            ASSERT_OK(validateBSON(o.objdata(), o.objsize(), BSONVersion::kLatest));
+            ASSERT_OK(validateBSON(o.objdata(), o.objsize()));
         } else {
-            ASSERT_NOT_OK(validateBSON(o.objdata(), o.objsize(), BSONVersion::kLatest));
+            ASSERT_NOT_OK(validateBSON(o.objdata(), o.objsize()));
         }
 
         delete[] x;
@@ -134,12 +134,12 @@ TEST(BSONValidate, MuckingData1) {
         data[i] = 0xc8U;
 
         numToRun++;
-        if (mine.valid(BSONVersion::kLatest)) {
+        if (mine.valid()) {
             numValid++;
             jsonSize += mine.jsonString().size();
-            ASSERT_OK(validateBSON(mine.objdata(), mine.objsize(), BSONVersion::kLatest));
+            ASSERT_OK(validateBSON(mine.objdata(), mine.objsize()));
         } else {
-            ASSERT_NOT_OK(validateBSON(mine.objdata(), mine.objsize(), BSONVersion::kLatest));
+            ASSERT_NOT_OK(validateBSON(mine.objdata(), mine.objsize()));
         }
     }
 
@@ -191,29 +191,29 @@ TEST(BSONValidate, Fuzz) {
         // to compare outputs against (BSONObj::valid() is a wrapper for validateBSON()).
         // Thus, the reason for this test is to ensure that validateBSON() doesn't trip
         // any ASAN or UBSAN check when fed fuzzed input.
-        validateBSON(fuzzed.objdata(), fuzzed.objsize(), BSONVersion::kLatest).isOK();
+        validateBSON(fuzzed.objdata(), fuzzed.objsize()).isOK();
     }
 }
 
 TEST(BSONValidateFast, Empty) {
     BSONObj x;
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
 }
 
 TEST(BSONValidateFast, RegEx) {
     BSONObjBuilder b;
     b.appendRegex("foo", "i");
     BSONObj x = b.obj();
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
 }
 
 TEST(BSONValidateFast, Simple0) {
     BSONObj x;
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
 
     x = BSON("foo" << 17 << "bar"
                    << "eliot");
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
 }
 
 TEST(BSONValidateFast, Simple2) {
@@ -225,7 +225,7 @@ TEST(BSONValidateFast, Simple2) {
         sprintf(buf, "bar%d", i);
         b.appendMaxForType(buf, i);
         BSONObj x = b.obj();
-        ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+        ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
     }
 }
 
@@ -240,15 +240,15 @@ TEST(BSONValidateFast, Simple3) {
         b.appendMaxForType(buf, i);
     }
     BSONObj x = b.obj();
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
 }
 
 TEST(BSONValidateFast, NestedObject) {
     BSONObj x = BSON("a" << 1 << "b"
                          << BSON("c" << 2 << "d" << BSONArrayBuilder().obj() << "e"
                                      << BSON_ARRAY("1" << 2 << 3)));
-    ASSERT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
-    ASSERT_NOT_OK(validateBSON(x.objdata(), x.objsize() / 2, BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(x.objdata(), x.objsize()));
+    ASSERT_NOT_OK(validateBSON(x.objdata(), x.objsize() / 2));
 }
 
 TEST(BSONValidateFast, ErrorWithId) {
@@ -257,7 +257,7 @@ TEST(BSONValidateFast, ErrorWithId) {
     ob.append("_id", 1);
     appendInvalidStringElement("not_id", &bb);
     const BSONObj x = ob.done();
-    const Status status = validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest);
+    const Status status = validateBSON(x.objdata(), x.objsize());
     ASSERT_NOT_OK(status);
     ASSERT_EQUALS(
         status.reason(),
@@ -270,7 +270,7 @@ TEST(BSONValidateFast, ErrorBeforeId) {
     appendInvalidStringElement("not_id", &bb);
     ob.append("_id", 1);
     const BSONObj x = ob.done();
-    const Status status = validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest);
+    const Status status = validateBSON(x.objdata(), x.objsize());
     ASSERT_NOT_OK(status);
     ASSERT_EQUALS(status.reason(),
                   "not null terminated string in element with field name 'not_id' in object with "
@@ -282,7 +282,7 @@ TEST(BSONValidateFast, ErrorNoId) {
     BSONObjBuilder ob(bb);
     appendInvalidStringElement("not_id", &bb);
     const BSONObj x = ob.done();
-    const Status status = validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest);
+    const Status status = validateBSON(x.objdata(), x.objsize());
     ASSERT_NOT_OK(status);
     ASSERT_EQUALS(status.reason(),
                   "not null terminated string in element with field name 'not_id' in object with "
@@ -294,7 +294,7 @@ TEST(BSONValidateFast, ErrorIsInId) {
     BSONObjBuilder ob(bb);
     appendInvalidStringElement("_id", &bb);
     const BSONObj x = ob.done();
-    const Status status = validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest);
+    const Status status = validateBSON(x.objdata(), x.objsize());
     ASSERT_NOT_OK(status);
     ASSERT_EQUALS(
         status.reason(),
@@ -309,7 +309,7 @@ TEST(BSONValidateFast, NonTopLevelId) {
                    << "not the real _id"));
     appendInvalidStringElement("not_id2", &bb);
     const BSONObj x = ob.done();
-    const Status status = validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest);
+    const Status status = validateBSON(x.objdata(), x.objsize());
     ASSERT_NOT_OK(status);
     ASSERT_EQUALS(status.reason(),
                   "not null terminated string in element with field name 'not_id2' in object with "
@@ -329,14 +329,14 @@ TEST(BSONValidateFast, StringHasSomething) {
                       + 4  // size
                   ,
                   x.objsize());
-    ASSERT_NOT_OK(validateBSON(x.objdata(), x.objsize(), BSONVersion::kLatest));
+    ASSERT_NOT_OK(validateBSON(x.objdata(), x.objsize()));
 }
 
 TEST(BSONValidateBool, BoolValuesAreValidated) {
     BSONObjBuilder bob;
     bob.append("x", false);
     const BSONObj obj = bob.done();
-    ASSERT_OK(validateBSON(obj.objdata(), obj.objsize(), BSONVersion::kLatest));
+    ASSERT_OK(validateBSON(obj.objdata(), obj.objsize()));
     const BSONElement x = obj["x"];
     // Legal, because we know that the BufBuilder gave
     // us back some heap memory, which isn't oringinally const.
@@ -346,9 +346,9 @@ TEST(BSONValidateBool, BoolValuesAreValidated) {
          ++val) {
         *writable = static_cast<char>(val);
         if ((val == 0) || (val == 1)) {
-            ASSERT_OK(validateBSON(obj.objdata(), obj.objsize(), BSONVersion::kLatest));
+            ASSERT_OK(validateBSON(obj.objdata(), obj.objsize()));
         } else {
-            ASSERT_NOT_OK(validateBSON(obj.objdata(), obj.objsize(), BSONVersion::kLatest));
+            ASSERT_NOT_OK(validateBSON(obj.objdata(), obj.objsize()));
         }
     }
 }
@@ -361,7 +361,7 @@ TEST(BSONValidateFast, InvalidType) {
     BSONObj obj(buffer);
 
     // Validate fails.
-    ASSERT_NOT_OK(validateBSON(obj.objdata(), obj.objsize(), BSONVersion::kLatest));
+    ASSERT_NOT_OK(validateBSON(obj.objdata(), obj.objsize()));
     ASSERT_THROWS_CODE(obj.woCompare(BSON("A" << 1)), DBException, 10320);
 }
 
diff --git a/src/mongo/bson/bsonobj.cpp b/src/mongo/bson/bsonobj.cpp
index 4c5f2982ae0..27963db4611 100644
--- a/src/mongo/bson/bsonobj.cpp
+++ b/src/mongo/bson/bsonobj.cpp
@@ -264,8 +264,8 @@ BSONObj BSONObj::jsonStringBuffer(JsonStringFormat format,
     }
 }
 
-bool BSONObj::valid(BSONVersion version) const {
-    return validateBSON(objdata(), objsize(), version).isOK();
+bool BSONObj::valid() const {
+    return validateBSON(objdata(), objsize()).isOK();
 }
 
 int BSONObj::woCompare(const BSONObj& r,
diff --git a/src/mongo/bson/bsonobj.h b/src/mongo/bson/bsonobj.h
index d8021e9f529..12374110747 100644
--- a/src/mongo/bson/bsonobj.h
+++ b/src/mongo/bson/bsonobj.h
@@ -576,10 +576,9 @@ public:
     bool hasFieldNames() const;
 
     /**
-     * Returns true if this object is valid according to the specified BSON version, and returns
-     * false otherwise.
+     * Returns true if this object is valid and returns false otherwise.
      */
-    bool valid(BSONVersion version) const;
+    bool valid() const;
 
     /** add all elements of the object to the specified vector */
     void elems(std::vector<BSONElement>&) const;
diff --git a/src/mongo/bson/bsontypes.h b/src/mongo/bson/bsontypes.h
index b2b5b7399e8..50588789dcc 100644
--- a/src/mongo/bson/bsontypes.h
+++ b/src/mongo/bson/bsontypes.h
@@ -56,11 +56,6 @@ extern const BSONObj kMaxBSONKey;
 extern const BSONObj kMinBSONKey;
 
 /**
-    determines BSON types considered valid by validate
-*/
-enum class BSONVersion { kV1_0, kV1_1, kLatest = kV1_1 };
-
-/**
     the complete list of valid BSON types
     see also bsonspec.org
 */