1 files changed, 51 insertions, 55 deletions
diff --git a/src/mongo/dbtests/mock/mock_conn_registry.cpp b/src/mongo/dbtests/mock/mock_conn_registry.cpp
index ad6cacb760c..2a34309a044 100644
--- a/src/mongo/dbtests/mock/mock_conn_registry.cpp
+++ b/src/mongo/dbtests/mock/mock_conn_registry.cpp
@@ -33,77 +33,73 @@
 
 namespace mongo {
 
-    using std::string;
+using std::string;
 
-    std::unique_ptr<MockConnRegistry> MockConnRegistry::_instance;
+std::unique_ptr<MockConnRegistry> MockConnRegistry::_instance;
 
-    MONGO_INITIALIZER(MockConnRegistry)(InitializerContext* context) {
-        return MockConnRegistry::init();
-    }
-
-    Status MockConnRegistry::init() {
-        MockConnRegistry::_instance.reset(new MockConnRegistry());
-        return Status::OK();
-    }
+MONGO_INITIALIZER(MockConnRegistry)(InitializerContext* context) {
+    return MockConnRegistry::init();
+}
 
-    MockConnRegistry::MockConnRegistry() : _mockConnStrHook(this) {}
+Status MockConnRegistry::init() {
+    MockConnRegistry::_instance.reset(new MockConnRegistry());
+    return Status::OK();
+}
 
-    MockConnRegistry* MockConnRegistry::get() {
-        return _instance.get();
-    }
+MockConnRegistry::MockConnRegistry() : _mockConnStrHook(this) {}
 
-    ConnectionString::ConnectionHook* MockConnRegistry::getConnStrHook() {
-        return &_mockConnStrHook;
-    }
+MockConnRegistry* MockConnRegistry::get() {
+    return _instance.get();
+}
 
-    void MockConnRegistry::addServer(MockRemoteDBServer* server) {
-        stdx::lock_guard<stdx::mutex> sl(_registryMutex);
+ConnectionString::ConnectionHook* MockConnRegistry::getConnStrHook() {
+    return &_mockConnStrHook;
+}
 
-        const std::string hostName(server->getServerAddress());
-        fassert(16533, _registry.count(hostName) == 0);
+void MockConnRegistry::addServer(MockRemoteDBServer* server) {
+    stdx::lock_guard<stdx::mutex> sl(_registryMutex);
 
-        _registry[hostName] = server;
-    }
+    const std::string hostName(server->getServerAddress());
+    fassert(16533, _registry.count(hostName) == 0);
 
-    bool MockConnRegistry::removeServer(const std::string& hostName) {
-        stdx::lock_guard<stdx::mutex> sl(_registryMutex);
-        return _registry.erase(hostName) == 1;
-    }
+    _registry[hostName] = server;
+}
 
-    void MockConnRegistry::clear() {
-        stdx::lock_guard<stdx::mutex> sl(_registryMutex);
-        _registry.clear();
-    }
+bool MockConnRegistry::removeServer(const std::string& hostName) {
+    stdx::lock_guard<stdx::mutex> sl(_registryMutex);
+    return _registry.erase(hostName) == 1;
+}
 
-    MockDBClientConnection* MockConnRegistry::connect(const std::string& connStr) {
-        stdx::lock_guard<stdx::mutex> sl(_registryMutex);
-        fassert(16534, _registry.count(connStr) == 1);
-        return new MockDBClientConnection(_registry[connStr], true);
-    }
+void MockConnRegistry::clear() {
+    stdx::lock_guard<stdx::mutex> sl(_registryMutex);
+    _registry.clear();
+}
 
-    MockConnRegistry::MockConnHook::MockConnHook(MockConnRegistry* registry):
-            _registry(registry) {
-    }
+MockDBClientConnection* MockConnRegistry::connect(const std::string& connStr) {
+    stdx::lock_guard<stdx::mutex> sl(_registryMutex);
+    fassert(16534, _registry.count(connStr) == 1);
+    return new MockDBClientConnection(_registry[connStr], true);
+}
 
-    MockConnRegistry::MockConnHook::~MockConnHook() {
-    }
+MockConnRegistry::MockConnHook::MockConnHook(MockConnRegistry* registry) : _registry(registry) {}
 
-    mongo::DBClientBase* MockConnRegistry::MockConnHook::connect(
-                const ConnectionString& connString,
-                std::string& errmsg,
-                double socketTimeout) {
-        const string hostName(connString.toString());
-        MockDBClientConnection* conn = _registry->connect(hostName);
+MockConnRegistry::MockConnHook::~MockConnHook() {}
 
-        if (!conn->connect(hostName.c_str(), errmsg)) {
-            // Assumption: connect never throws, so no leak.
-            delete conn;
+mongo::DBClientBase* MockConnRegistry::MockConnHook::connect(const ConnectionString& connString,
+                                                             std::string& errmsg,
+                                                             double socketTimeout) {
+    const string hostName(connString.toString());
+    MockDBClientConnection* conn = _registry->connect(hostName);
 
-            // mimic ConnectionString::connect for MASTER type connection to return NULL
-            // if the destination is unreachable.
-            return NULL;
-        }
+    if (!conn->connect(hostName.c_str(), errmsg)) {
+        // Assumption: connect never throws, so no leak.
+        delete conn;
 
-        return conn;
+        // mimic ConnectionString::connect for MASTER type connection to return NULL
+        // if the destination is unreachable.
+        return NULL;
     }
+
+    return conn;
+}
 }