1 files changed, 22 insertions, 48 deletions

diff --git a/src/mongo/bson/bsonobj.cpp b/src/mongo/bson/bsonobj.cpp
index f0c5946565c..7b5fa7dae04 100644
--- a/src/mongo/bson/bsonobj.cpp
+++ b/src/mongo/bson/bsonobj.cpp
@@ -138,71 +138,41 @@ BSONObj BSONObj::getOwned(const BSONObj& obj) {
     return obj.getOwned();
 }
 
-BSONObj BSONObj::redact(RedactLevel level,
-                        std::function<std::string(const BSONElement&)> fieldNameRedactor) const {
+BSONObj BSONObj::redact(bool onlyEncryptedFields) const {
     _validateUnownedSize(objsize());
 
     // Helper to get an "internal function" to be able to do recursion
     struct redactor {
-        void appendRedactedElem(BSONObjBuilder& builder,
-                                const StringData& fieldNameString,
-                                bool appendMask) {
+        void appendRedactedElem(BSONObjBuilder& builder, const BSONElement& e, bool appendMask) {
             if (appendMask) {
-                builder.append(fieldNameString, "###"_sd);
+                builder.append(e.fieldNameStringData(), "###"_sd);
             } else {
-                builder.appendNull(fieldNameString);
+                builder.appendNull(e.fieldNameStringData());
             }
         }
 
         void operator()(BSONObjBuilder& builder,
                         const BSONObj& obj,
                         bool appendMask,
-                        RedactLevel level,
-                        std::function<std::string(const BSONElement&)> fieldNameRedactor) {
+                        bool onlyEncryptedFields) {
             for (BSONElement e : obj) {
-                StringData fieldNameString;
-                // Temporarily allocated string that must live long enough to be copied by builder.
-                std::string tempString;
-                if (!fieldNameRedactor) {
-                    fieldNameString = e.fieldNameStringData();
-                } else {
-                    tempString = fieldNameRedactor(e);
-                    fieldNameString = {tempString};
-                }
                 if (e.type() == Object) {
-                    BSONObjBuilder subBuilder = builder.subobjStart(fieldNameString);
-                    operator()(subBuilder, e.Obj(), appendMask, level, fieldNameRedactor);
+                    BSONObjBuilder subBuilder = builder.subobjStart(e.fieldNameStringData());
+                    operator()(subBuilder, e.Obj(), appendMask, onlyEncryptedFields);
                     subBuilder.done();
                 } else if (e.type() == Array) {
-                    BSONObjBuilder subBuilder = builder.subarrayStart(fieldNameString);
-                    operator()(subBuilder, e.Obj(), appendMask, level, fieldNameRedactor);
+                    BSONObjBuilder subBuilder = builder.subarrayStart(e.fieldNameStringData());
+                    operator()(subBuilder, e.Obj(), appendMask, onlyEncryptedFields);
                     subBuilder.done();
                 } else {
-                    // SERVER-79068 Templatizing this could be a good opportunity for performance
-                    // improvements.
-                    switch (level) {
-                        case RedactLevel::all: {
-                            appendRedactedElem(builder, fieldNameString, appendMask);
-                            break;
-                        }
-                        case RedactLevel::encryptedAndSensitive: {
-                            if (e.type() == BinData &&
-                                (e.binDataType() == BinDataType::Encrypt ||
-                                 e.binDataType() == BinDataType::Sensitive)) {
-                                appendRedactedElem(builder, fieldNameString, appendMask);
-                            } else {
-                                builder.append(e);
-                            }
-                            break;
-                        }
-                        case RedactLevel::sensitiveOnly: {
-                            if (e.type() == BinData && e.binDataType() == BinDataType::Sensitive) {
-                                appendRedactedElem(builder, fieldNameString, appendMask);
-                            } else {
-                                builder.append(e);
-                            }
-                            break;
+                    if (onlyEncryptedFields) {
+                        if (e.type() == BinData && e.binDataType() == BinDataType::Encrypt) {
+                            appendRedactedElem(builder, e, appendMask);
+                        } else {
+                            builder.append(e);
                         }
+                    } else {
+                        appendRedactedElem(builder, e, appendMask);
                     }
                 }
             }
@@ -211,7 +181,7 @@ BSONObj BSONObj::redact(RedactLevel level,
 
     try {
         BSONObjBuilder builder;
-        redactor()(builder, *this, /*appendMask=*/true, level, fieldNameRedactor);
+        redactor()(builder, *this, /*appendMask=*/true, onlyEncryptedFields);
         return builder.obj();
     } catch (const ExceptionFor<ErrorCodes::BSONObjectTooLarge>&) {
     }
@@ -221,7 +191,7 @@ BSONObj BSONObj::redact(RedactLevel level,
     // we use BSONType::jstNull, which ensures the redacted object will not be larger than the
     // original.
     BSONObjBuilder builder;
-    redactor()(builder, *this, /*appendMask=*/false, level, fieldNameRedactor);
+    redactor()(builder, *this, /*appendMask=*/false, onlyEncryptedFields);
     return builder.obj();
 }
 
@@ -328,6 +298,10 @@ BSONObj BSONObj::jsonStringBuffer(JsonStringFormat format,
     }
 }
 
+bool BSONObj::valid() const {
+    return validateBSON(objdata(), objsize()).isOK();
+}
+
 int BSONObj::woCompare(const BSONObj& r,
                        const Ordering& o,
                        ComparisonRulesSet rules,