Add an unused implementation NoOpTransportSocketCallbacks

include/envoy/network/transport_socket.h

@@ -137,6 +137,11 @@ class TransportSocket {
    * @return the const SSL connection data if this is an SSL connection, or nullptr if it is not.
    */
   virtual const Ssl::Connection* ssl() const PURE;
+
+  /**
+   * @return the TransportSocketCallbacks object passed in through setTransportSocketCallbacks().
+   */
+  virtual TransportSocketCallbacks* callbacks() PURE;
 };
 
 typedef std::unique_ptr<TransportSocket> TransportSocketPtr;

source/common/network/raw_buffer_socket.h

@@ -21,6 +21,7 @@ class RawBufferSocket : public TransportSocket, protected Logger::Loggable<Logge
   IoResult doWrite(Buffer::Instance& buffer, bool end_stream) override;
   Ssl::Connection* ssl() override { return nullptr; }
   const Ssl::Connection* ssl() const override { return nullptr; }
+  TransportSocketCallbacks* callbacks() override { return callbacks_; }
 
 private:
   TransportSocketCallbacks* callbacks_{};

source/common/ssl/ssl_socket.h

@@ -45,6 +45,7 @@ class SslSocket : public Network::TransportSocket,
   void onConnected() override;
   Ssl::Connection* ssl() override { return this; }
   const Ssl::Connection* ssl() const override { return this; }
+  Network::TransportSocketCallbacks* callbacks() override { return callbacks_; }
 
   SSL* rawSslForTest() { return ssl_.get(); }
 

source/extensions/transport_sockets/alts/BUILD

@@ -53,3 +53,9 @@ envoy_cc_library(
         "//source/common/buffer:buffer_lib",
     ],
 )
+
+envoy_cc_library(
+    name = "noop_transport_socket_callbacks_lib",
+    hdrs = ["noop_transport_socket_callbacks.h"],
+    deps = ["//include/envoy/network:transport_socket_interface"],
+)

source/extensions/transport_sockets/alts/noop_transport_socket_callbacks.h

@@ -0,0 +1,34 @@
+#include "envoy/network/transport_socket.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace TransportSockets {
+namespace Alts {
+
+/**
+ * A TransportSocketCallbacks for wrapped TransportSocket object. Some
+ * TransportSocket implementation wraps another socket which does actual I/O.
+ * This class is used by the wrapped socket as its callbacks instead of the real
+ * connection to hold back callbacks from the underlying socket to connection.
+ */
+class NoOpTransportSocketCallbacks : public Network::TransportSocketCallbacks {
+public:
+  explicit NoOpTransportSocketCallbacks(Network::TransportSocket* parent) : parent_(parent) {}
+
+  int fd() const override { return parent_->callbacks()->fd(); }
+  Network::Connection& connection() override { return parent_->callbacks()->connection(); }
+  bool shouldDrainReadBuffer() override { return false; }
+  /*
+   * No-op for these two methods to hold back the callbacks.
+   */
+  void setReadBufferReady() override {}
+  void raiseEvent(Network::ConnectionEvent) override {}
+
+private:
+  Network::TransportSocket* parent_;
+};
+
+} // namespace Alts
+} // namespace TransportSockets
+} // namespace Extensions
+} // namespace Envoy

source/extensions/transport_sockets/capture/capture.h

@@ -27,6 +27,7 @@ class CaptureSocket : public Network::TransportSocket {
   void onConnected() override;
   Ssl::Connection* ssl() override;
   const Ssl::Connection* ssl() const override;
+  Network::TransportSocketCallbacks* callbacks() override { return callbacks_; }
 
 private:
   const std::string& path_prefix_;

test/common/network/connection_impl_test.cc

@@ -879,13 +879,10 @@ class MockTransportConnectionImplTest : public testing::Test {
     EXPECT_CALL(dispatcher_, createFileEvent_(0, _, _, _))
         .WillOnce(DoAll(SaveArg<1>(&file_ready_cb_), Return(file_event_)));
     transport_socket_ = new NiceMock<MockTransportSocket>;
-    EXPECT_CALL(*transport_socket_, setTransportSocketCallbacks(_))
-        .WillOnce(Invoke([this](TransportSocketCallbacks& callbacks) {
-          transport_socket_callbacks_ = &callbacks;
-        }));
     connection_.reset(
         new ConnectionImpl(dispatcher_, std::make_unique<ConnectionSocketImpl>(0, nullptr, nullptr),
                            TransportSocketPtr(transport_socket_), true));
+    transport_socket_callbacks_ = transport_socket_->callbacks();
     connection_->addConnectionCallbacks(callbacks_);
   }
 

test/extensions/transport_sockets/alts/BUILD

@@ -32,3 +32,13 @@ envoy_extension_cc_test(
         "//test/mocks/event:event_mocks",
     ],
 )
+
+envoy_extension_cc_test(
+    name = "noop_transport_socket_callbacks_test",
+    srcs = ["noop_transport_socket_callbacks_test.cc"],
+    extension_name = "envoy.transport_sockets.alts",
+    deps = [
+        "//source/extensions/transport_sockets/alts:noop_transport_socket_callbacks_lib",
+        "//test/mocks/network:network_mocks",
+    ],
+)

test/extensions/transport_sockets/alts/noop_transport_socket_callbacks_test.cc

@@ -0,0 +1,60 @@
+#include "extensions/transport_sockets/alts/noop_transport_socket_callbacks.h"
+
+#include "test/mocks/network/mocks.h"
+
+#include "gtest/gtest.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace TransportSockets {
+namespace Alts {
+namespace {
+
+class TestTransportSocketCallbacks : public Network::TransportSocketCallbacks {
+public:
+  TestTransportSocketCallbacks(Network::Connection* connection) : connection_(connection) {}
+
+  int fd() const override { return 1; }
+  Network::Connection& connection() override { return *connection_; }
+  bool shouldDrainReadBuffer() override { return false; }
+  void setReadBufferReady() override { set_read_buffer_ready_ = true; }
+  void raiseEvent(Network::ConnectionEvent) override { event_raised_ = true; }
+
+  bool event_raised() const { return event_raised_; }
+  bool set_read_buffer_ready() const { return set_read_buffer_ready_; }
+
+private:
+  bool event_raised_{false};
+  bool set_read_buffer_ready_{false};
+  Network::Connection* connection_;
+};
+
+class NoOpTransportSocketCallbacksTest : public testing::Test {
+protected:
+  NoOpTransportSocketCallbacksTest()
+      : wrapper_callbacks_(&connection_), wrapped_callbacks_(&wrapper_socket_) {
+    wrapper_socket_.setTransportSocketCallbacks(wrapper_callbacks_);
+  }
+
+  Network::MockConnection connection_;
+  TestTransportSocketCallbacks wrapper_callbacks_;
+  Network::MockTransportSocket wrapper_socket_;
+  NoOpTransportSocketCallbacks wrapped_callbacks_;
+};
+
+TEST_F(NoOpTransportSocketCallbacksTest, TestAllCallbacks) {
+  EXPECT_EQ(wrapper_callbacks_.fd(), wrapped_callbacks_.fd());
+  EXPECT_EQ(&connection_, &wrapped_callbacks_.connection());
+  EXPECT_FALSE(wrapped_callbacks_.shouldDrainReadBuffer());
+
+  wrapped_callbacks_.setReadBufferReady();
+  EXPECT_FALSE(wrapper_callbacks_.set_read_buffer_ready());
+  wrapped_callbacks_.raiseEvent(Network::ConnectionEvent::Connected);
+  EXPECT_FALSE(wrapper_callbacks_.event_raised());
+}
+
+} // namespace
+} // namespace Alts
+} // namespace TransportSockets
+} // namespace Extensions
+} // namespace Envoy

test/mocks/network/mocks.h

@@ -428,7 +428,9 @@ class MockTransportSocket : public TransportSocket {
   MockTransportSocket();
   ~MockTransportSocket();
 
-  MOCK_METHOD1(setTransportSocketCallbacks, void(TransportSocketCallbacks& callbacks));
+  void setTransportSocketCallbacks(TransportSocketCallbacks& callbacks) override {
+    callbacks_ = &callbacks;
+  }
   MOCK_CONST_METHOD0(protocol, std::string());
   MOCK_METHOD0(canFlushClose, bool());
   MOCK_METHOD1(closeSocket, void(Network::ConnectionEvent event));
@@ -437,6 +439,10 @@ class MockTransportSocket : public TransportSocket {
   MOCK_METHOD0(onConnected, void());
   MOCK_METHOD0(ssl, Ssl::Connection*());
   MOCK_CONST_METHOD0(ssl, const Ssl::Connection*());
+  Network::TransportSocketCallbacks* callbacks() override { return callbacks_; }
+
+private:
+  Network::TransportSocketCallbacks* callbacks_;
 };
 
 class MockTransportSocketFactory : public TransportSocketFactory {