AsyncTransportWrapper => AsyncTransport

Summary:
AsyncTransportWrapper is deprecated -- with its prior functionality moved up
to AsyncTransport

(Note: this ignores all push blocking failures!)

Reviewed By: yfeldblum

Differential Revision: D21916601

fbshipit-source-id: 12b91859dcffcc9cbdc43a2a5f3063d27e99ce68

tutorial.md

@@ -42,7 +42,7 @@ This needs to be the final handler in the pipeline. Now the definition of the pi
 // where we define the chain of handlers for each messeage received
 class EchoPipelineFactory : public PipelineFactory<EchoPipeline> {
  public:
-  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransportWrapper> sock) {
+  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransport> sock) {
     auto pipeline = EchoPipeline::create();
     pipeline->addBack(AsyncSocketHandler(sock));
     pipeline->addBack(LineBasedFrameDecoder(8192));
@@ -99,7 +99,7 @@ class EchoHandler : public HandlerAdapter<std::string> {
 // where we define the chain of handlers for each message received
 class EchoPipelineFactory : public PipelineFactory<EchoPipeline> {
  public:
-  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransportWrapper> sock) {
+  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransport> sock) {
     auto pipeline = EchoPipeline::create();
     pipeline->addBack(AsyncSocketHandler(sock));
     pipeline->addBack(LineBasedFrameDecoder(8192));
@@ -154,7 +154,7 @@ Now onto the client’s pipeline factory. It is identical the server’s pipelin
 // chains the handlers together to define the response pipeline
 class EchoPipelineFactory : public PipelineFactory<EchoPipeline> {
  public:
-  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransportWrapper> sock) {
+  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransport> sock) {
     auto pipeline = EchoPipeline::create();
     pipeline->addBack(AsyncSocketHandler(sock));
     pipeline->addBack(
@@ -207,7 +207,7 @@ class EchoHandler : public HandlerAdapter<std::string> {
 // chains the handlers together to define the response pipeline
 class EchoPipelineFactory : public PipelineFactory<EchoPipeline> {
  public:
-  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransportWrapper> sock) {
+  EchoPipeline::Ptr newPipeline(std::shared_ptr<AsyncTransport> sock) {
     auto pipeline = EchoPipeline::create();
     pipeline->addBack(AsyncSocketHandler(sock));
     pipeline->addBack(

wangle/acceptor/Acceptor.cpp

@@ -17,6 +17,7 @@
 #include <wangle/acceptor/Acceptor.h>
 
 #include <fizz/server/TicketTypes.h>
+#include <folly/io/async/AsyncTransport.h>
 #include <folly/io/async/AsyncSSLSocket.h>
 #include <folly/io/async/AsyncSocket.h>
 #include <folly/io/async/EventBase.h>
@@ -34,7 +35,7 @@
 using folly::AsyncServerSocket;
 using folly::AsyncSocket;
 using folly::AsyncSSLSocket;
-using folly::AsyncTransportWrapper;
+using folly::AsyncTransport;
 using folly::EventBase;
 using folly::SocketAddress;
 using std::string;
@@ -315,7 +316,7 @@ void Acceptor::startHandshakeManager(
 }
 
 void Acceptor::connectionReady(
-    AsyncTransportWrapper::UniquePtr sock,
+    AsyncTransport::UniquePtr sock,
     const SocketAddress& clientAddr,
     const string& nextProtocolName,
     SecureTransportType secureTransportType,
@@ -338,7 +339,7 @@ void Acceptor::connectionReady(
 }
 
 void Acceptor::plaintextConnectionReady(
-    AsyncTransportWrapper::UniquePtr sock,
+    AsyncTransport::UniquePtr sock,
     const SocketAddress& clientAddr,
     const string& nextProtocolName,
     SecureTransportType secureTransportType,
@@ -352,7 +353,7 @@ void Acceptor::plaintextConnectionReady(
 }
 
 void Acceptor::sslConnectionReady(
-    AsyncTransportWrapper::UniquePtr sock,
+    AsyncTransport::UniquePtr sock,
     const SocketAddress& clientAddr,
     const string& nextProtocol,
     SecureTransportType secureTransportType,

wangle/acceptor/Acceptor.h

@@ -39,7 +39,6 @@
 
 namespace wangle {
 
-class AsyncTransport;
 class ManagedConnection;
 class SecurityProtocolContextManager;
 class SSLContextManager;
@@ -287,7 +286,7 @@ class Acceptor : public folly::AsyncServerSocket::AcceptCallback,
    * subclasses to deal with plaintext connections.
    */
   virtual void plaintextConnectionReady(
-      folly::AsyncTransportWrapper::UniquePtr sock,
+      folly::AsyncTransport::UniquePtr sock,
       const folly::SocketAddress& clientAddr,
       const std::string& nextProtocolName,
       SecureTransportType secureTransportType,
@@ -300,7 +299,7 @@ class Acceptor : public folly::AsyncServerSocket::AcceptCallback,
    * for SSL connections.
    */
   void connectionReady(
-      folly::AsyncTransportWrapper::UniquePtr sock,
+      folly::AsyncTransport::UniquePtr sock,
       const folly::SocketAddress& clientAddr,
       const std::string& nextProtocolName,
       SecureTransportType secureTransportType,
@@ -311,7 +310,7 @@ class Acceptor : public folly::AsyncServerSocket::AcceptCallback,
    * pending SSL connections. This should normally not be overridden.
    */
   virtual void sslConnectionReady(
-      folly::AsyncTransportWrapper::UniquePtr sock,
+      folly::AsyncTransport::UniquePtr sock,
       const folly::SocketAddress& clientAddr,
       const std::string& nextProtocol,
       SecureTransportType secureTransportType,
@@ -328,7 +327,7 @@ class Acceptor : public folly::AsyncServerSocket::AcceptCallback,
    * sock may be nullptr.
    */
   virtual void updateSSLStats(
-      const folly::AsyncTransportWrapper* /*sock*/,
+      const folly::AsyncTransport* /*sock*/,
       std::chrono::milliseconds /*acceptLatency*/,
       SSLErrorEnum /*error*/,
       const folly::exception_wrapper& /*ex*/) noexcept {}
@@ -370,7 +369,7 @@ class Acceptor : public folly::AsyncServerSocket::AcceptCallback,
    *                            requested by the client.
    */
   virtual void onNewConnection(
-      folly::AsyncTransportWrapper::UniquePtr /*sock*/,
+      folly::AsyncTransport::UniquePtr /*sock*/,
       const folly::SocketAddress* /*address*/,
       const std::string& /*nextProtocolName*/,
       SecureTransportType /*secureTransportType*/,

wangle/acceptor/AcceptorHandshakeManager.cpp

@@ -27,7 +27,7 @@ void AcceptorHandshakeManager::start(
 }
 
 void AcceptorHandshakeManager::connectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<SSLErrorEnum> sslErr) noexcept {
@@ -54,7 +54,7 @@ void AcceptorHandshakeManager::connectionReady(
 }
 
 void AcceptorHandshakeManager::connectionError(
-    folly::AsyncTransportWrapper* transport,
+    folly::AsyncTransport* transport,
     folly::exception_wrapper ex,
     folly::Optional<SSLErrorEnum> sslErr) noexcept {
   if (sslErr) {

wangle/acceptor/AcceptorHandshakeManager.h

@@ -45,7 +45,7 @@ class AcceptorHandshakeHelper : public folly::DelayedDestruction {
      * If sslErr is set, Acceptor::updateSSLStats will be called.
      */
     virtual void connectionReady(
-        folly::AsyncTransportWrapper::UniquePtr transport,
+        folly::AsyncTransport::UniquePtr transport,
         std::string nextProtocol,
         SecureTransportType secureTransportType,
         folly::Optional<SSLErrorEnum> sslErr) noexcept = 0;
@@ -56,7 +56,7 @@ class AcceptorHandshakeHelper : public folly::DelayedDestruction {
      * If sslErr is set, Acceptor::updateSSLStats will be called.
      */
     virtual void connectionError(
-        folly::AsyncTransportWrapper* transport,
+        folly::AsyncTransport* transport,
         folly::exception_wrapper ex,
         folly::Optional<SSLErrorEnum> sslErr) noexcept = 0;
   };
@@ -115,14 +115,14 @@ class AcceptorHandshakeManager : public ManagedConnection,
 
  protected:
   void connectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<SSLErrorEnum>
           details) noexcept override;
 
   void connectionError(
-      folly::AsyncTransportWrapper* transport,
+      folly::AsyncTransport* transport,
       folly::exception_wrapper ex,
       folly::Optional<SSLErrorEnum>
           details) noexcept override;

wangle/acceptor/EvbHandshakeHelper.cpp

@@ -84,7 +84,7 @@ void EvbHandshakeHelper::dropConnection(SSLErrorEnum reason) {
 }
 
 void EvbHandshakeHelper::connectionReady(
-    folly::AsyncTransportWrapper::UniquePtr transport,
+    folly::AsyncTransport::UniquePtr transport,
     std::string nextProtocol,
     SecureTransportType secureTransportType,
     folly::Optional<SSLErrorEnum> sslErr) noexcept {
@@ -136,7 +136,7 @@ void EvbHandshakeHelper::connectionReady(
 }
 
 void EvbHandshakeHelper::connectionError(
-    folly::AsyncTransportWrapper* transport,
+    folly::AsyncTransport* transport,
     folly::exception_wrapper ex,
     folly::Optional<SSLErrorEnum> sslErr) noexcept {
   DCHECK(transport->getEventBase() == handshakeEvb_);

wangle/acceptor/EvbHandshakeHelper.h

@@ -50,13 +50,13 @@ class EvbHandshakeHelper : public AcceptorHandshakeHelper,
 
   // Exposing these for tests, do not directly call these callbacks.
   virtual void connectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<SSLErrorEnum> sslErr) noexcept override;
 
   virtual void connectionError(
-      folly::AsyncTransportWrapper* transport,
+      folly::AsyncTransport* transport,
       folly::exception_wrapper ex,
       folly::Optional<SSLErrorEnum> sslErr) noexcept override;
 

wangle/acceptor/SocketPeeker.h

@@ -22,7 +22,7 @@
 
 namespace wangle {
 
-class SocketPeeker : public folly::AsyncTransportWrapper::ReadCallback,
+class SocketPeeker : public folly::AsyncTransport::ReadCallback,
                      public folly::DelayedDestruction {
  public:
   using UniquePtr =

wangle/acceptor/test/AcceptorHelperMocks.h

@@ -38,18 +38,18 @@ class MockHandshakeHelperCallback
   MOCK_METHOD3(
       connectionError_,
       void(
-          folly::AsyncTransportWrapper*,
+          folly::AsyncTransport*,
           folly::exception_wrapper,
           folly::Optional<wangle::SSLErrorEnum>));
   void connectionError(
-      folly::AsyncTransportWrapper* transport,
+      folly::AsyncTransport* transport,
       folly::exception_wrapper ex,
       folly::Optional<wangle::SSLErrorEnum> sslErr) noexcept override {
     connectionError_(transport, ex, sslErr);
   }
 
   void connectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<wangle::SSLErrorEnum> sslErr) noexcept override {
@@ -113,13 +113,13 @@ struct UseSharedPtrPolicy<MockHandshakeHelperCallback<P>> {
   MOCK_METHOD4(
       connectionReadyInternal,
       void(
-          std::shared_ptr<folly::AsyncTransportWrapper>,
+          std::shared_ptr<folly::AsyncTransport>,
           std::string,
           SecureTransportType,
           folly::Optional<wangle::SSLErrorEnum>));
 
   void dispatchConnectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<wangle::SSLErrorEnum> sslErr) {
@@ -136,13 +136,13 @@ struct UseOwnedRawPtrPolicy<MockHandshakeHelperCallback<P>> {
   MOCK_METHOD4(
       connectionReadyInternalRaw,
       void(
-          folly::AsyncTransportWrapper*,
+          folly::AsyncTransport*,
           std::string,
           SecureTransportType,
           folly::Optional<wangle::SSLErrorEnum>));
 
   void dispatchConnectionReady(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       std::string nextProtocol,
       SecureTransportType secureTransportType,
       folly::Optional<wangle::SSLErrorEnum> sslErr) {

wangle/acceptor/test/EvbHandshakeHelperTest.cpp

@@ -97,7 +97,7 @@ TEST_F(EvbHandshakeHelperTest, TestSuccessPath) {
 
         sock->getEventBase()->runInLoop([sock, cb] {
           cb->connectionReady(
-              AsyncTransportWrapper::UniquePtr(sock),
+              AsyncTransport::UniquePtr(sock),
               "h2",
               SecureTransportType::TLS,
               folly::none);
@@ -156,7 +156,7 @@ TEST_F(EvbHandshakeHelperTest, TestDropConnection) {
     barrier.post();
   }));
 
-  AsyncTransportWrapper* transport;
+  AsyncTransport* transport;
   EXPECT_CALL(mockCb_, connectionError_(_, _, _))
       .WillOnce(SaveArg<0>(&transport));
 

wangle/acceptor/test/PeekingAcceptorHandshakeHelperTest.cpp

@@ -135,7 +135,7 @@ TEST_F(PeekingAcceptorHandshakeHelperTest, TestPeek2ndSuccess) {
 
 
 TEST_F(PeekingAcceptorHandshakeHelperTest, TestEOFDuringPeek) {
-  AsyncTransportWrapper::ReadCallback* rcb;
+  AsyncTransport::ReadCallback* rcb;
   EXPECT_CALL(*sslSock_, setReadCB(_))
     .WillOnce(SaveArg<0>(&rcb));
   EXPECT_CALL(*sslSock_, setReadCB(nullptr));

wangle/bootstrap/AcceptRoutingHandler-inl.h

@@ -29,7 +29,7 @@ void AcceptRoutingHandler<Pipeline, R>::read(
   populateAcceptors();
 
   const auto& connInfo = boost::get<ConnInfo&>(conn);
-  auto socket = std::shared_ptr<folly::AsyncTransportWrapper>(
+  auto socket = std::shared_ptr<folly::AsyncTransport>(
       connInfo.sock, folly::DelayedDestruction::Destructor());
 
   uint64_t connId = nextConnId_++;
@@ -87,7 +87,7 @@ void AcceptRoutingHandler<Pipeline, R>::onRoutingData(
 
   // Fetch the socket from the pipeline and pause reading from the
   // socket
-  auto socket = std::dynamic_pointer_cast<folly::AsyncTransportWrapper>(
+  auto socket = std::dynamic_pointer_cast<folly::AsyncTransport>(
       routingPipeline->getTransport());
   CHECK(socket);
   routingPipeline->transportInactive();

wangle/bootstrap/AcceptRoutingHandler.h

@@ -117,7 +117,7 @@ class RoutingDataPipelineFactory {
   virtual ~RoutingDataPipelineFactory() {}
 
   virtual typename Pipeline::Ptr newPipeline(
-      std::shared_ptr<folly::AsyncTransportWrapper> socket,
+      std::shared_ptr<folly::AsyncTransport> socket,
       const R& routingData,
       RoutingDataHandler<R>* routingHandler,
       std::shared_ptr<TransportInfo> transportInfo) = 0;

wangle/bootstrap/BaseClientBootstrap.h

@@ -117,7 +117,7 @@ class BaseClientBootstrap {
   }
 
   virtual void makePipeline(
-      std::shared_ptr<folly::AsyncTransportWrapper> socket) {
+      std::shared_ptr<folly::AsyncTransport> socket) {
     pipeline_ = pipelineFactory_->newPipeline(socket);
   }
 

wangle/bootstrap/ServerBootstrap-inl.h

@@ -155,7 +155,7 @@ class ServerAcceptor : public Acceptor,
     }
 
     auto connInfo = boost::get<ConnInfo&>(conn);
-    folly::AsyncTransportWrapper::UniquePtr transport(connInfo.sock);
+    folly::AsyncTransport::UniquePtr transport(connInfo.sock);
 
     // Setup local and remote addresses
     auto tInfoPtr = std::make_shared<TransportInfo>(connInfo.tinfo);
@@ -168,7 +168,7 @@ class ServerAcceptor : public Acceptor,
         std::make_shared<std::string>(connInfo.nextProtoName);
 
     auto pipeline = childPipelineFactory_->newPipeline(
-        std::shared_ptr<folly::AsyncTransportWrapper>(
+        std::shared_ptr<folly::AsyncTransport>(
             transport.release(), folly::DelayedDestruction::Destructor()));
     pipeline->setTransportInfo(tInfoPtr);
     auto connection = new ServerConnection(std::move(pipeline));
@@ -183,7 +183,7 @@ class ServerAcceptor : public Acceptor,
 
   /* See Acceptor::onNewConnection for details */
   void onNewConnection(
-      folly::AsyncTransportWrapper::UniquePtr transport,
+      folly::AsyncTransport::UniquePtr transport,
       const folly::SocketAddress* clientAddr,
       const std::string& nextProtocolName,
       SecureTransportType secureTransportType,

wangle/bootstrap/test/AcceptRoutingHandlerTest.cpp

@@ -26,7 +26,7 @@ using TestClient = ClientBootstrap<DefaultPipeline>;
 class TestClientPipelineFactory : public PipelineFactory<DefaultPipeline> {
  public:
   DefaultPipeline::Ptr newPipeline(
-      std::shared_ptr<AsyncTransportWrapper> socket) override {
+      std::shared_ptr<AsyncTransport> socket) override {
     // Socket should be connected already
     EXPECT_TRUE(socket->good());