1. set high water callback for send message.

2. dont' send msg when TcpConnection already closed.

Author: IronsDu

examples/BenchWebsocket.cpp

@@ -28,14 +28,14 @@ static void sendPacket(const HttpSession::Ptr& session, const char* data, size_t
     bw.writeINT8('"');
     bw.writeINT8('}');
 
-    auto frame = std::make_shared<std::string>();
+    std::string frame;
     WebSocketFormat::wsFrameBuild(bw.getData(),
         bw.getPos(), 
-        *frame, 
+        frame,
         WebSocketFormat::WebSocketFrameType::TEXT_FRAME, 
         true, 
         true);
-    session->send(frame);
+    session->send(std::move(frame));
 }
 
 int main(int argc, char **argv)

examples/BroadCastServer.cpp

@@ -49,7 +49,7 @@ static size_t getClientNum()
     return clients.size();
 }
 
-static void broadCastPacket(const std::shared_ptr<std::string>& packet)
+static void broadCastPacket(const brynet::net::SendableMsg::Ptr & packet)
 {
     auto packetLen = packet->size();
     RecvPacketNum++;
@@ -115,7 +115,7 @@ int main(int argc, char** argv)
                         break;
                     }
 
-                    auto packet = std::make_shared<std::string>(buffer, packetLen);
+                    auto packet = brynet::net::MakeStringMsg(buffer, packetLen);
                     mainLoop->runAsyncFunctor([packet]()
                     {
                         broadCastPacket(packet);

examples/HttpServer.cpp

@@ -53,14 +53,14 @@ int main(int argc, char **argv)
                 std::cout << "frame enter of type:" << int(opcode) << std::endl;
                 std::cout << "payload is:" << payload << std::endl;
                 // echo frame
-                auto frame = std::make_shared<std::string>();
+                std::string frame;
                 WebSocketFormat::wsFrameBuild(payload.c_str(),
                     payload.size(),
-                    *frame,
+                    frame,
                     WebSocketFormat::WebSocketFrameType::TEXT_FRAME,
                     true,
                     false);
-                httpSession->send(frame);
+                httpSession->send(std::move(frame));
             };
 
     wrapper::HttpListenerBuilder listenBuilder;

include/brynet/net/TcpConnection.hpp

@@ -47,6 +47,42 @@ namespace brynet { namespace net {
         virtual size_t          size() = 0;
     };
 
+    class StringSendMsg : public SendableMsg
+    {
+    public:
+        explicit StringSendMsg(const char* buffer, size_t len)
+        :
+        mMsg(buffer, len)
+        {}
+
+        explicit StringSendMsg(std::string buffer)
+        :
+        mMsg(std::move(buffer))
+        {}
+
+        const void* data() override
+        {
+            return static_cast<const void*>(mMsg.data());
+        }
+        size_t  size() override
+        {
+            return mMsg.size();
+        }
+
+    private:
+        std::string    mMsg;
+    };
+
+    static  SendableMsg::Ptr MakeStringMsg(const char* buffer, size_t len)
+    {
+        return std::make_shared<StringSendMsg>(buffer, len);
+    }
+
+    static  SendableMsg::Ptr MakeStringMsg(std::string buffer)
+    {
+        return std::make_shared<StringSendMsg>(std::move(buffer));
+    }
+
     class TcpConnection :   public Channel, 
                             public brynet::base::NonCopyable, 
                             public std::enable_shared_from_this<TcpConnection>
@@ -162,40 +198,14 @@ namespace brynet { namespace net {
             size_t len, 
             PacketSendedCallback&& callback = nullptr)
         {
-            send(std::make_shared<std::string>(buffer, len), std::move(callback));
+            send(MakeStringMsg(buffer, len), std::move(callback));
         }
 
         void                            send(
-            const std::shared_ptr<std::string>& packet,
+            std::string buffer,
             PacketSendedCallback&& callback = nullptr)
         {
-            class StringSendMsg : public SendableMsg
-            {
-            public:
-                explicit StringSendMsg(std::shared_ptr<std::string>&&  msg)
-                    :
-                    mMsg(std::move(msg))
-                {}
-                explicit StringSendMsg(const std::shared_ptr<std::string>&  msg)
-                    :
-                    mMsg(msg)
-                {}
-
-                const void* data() override
-                {
-                    return static_cast<const void*>(mMsg->data());
-                }
-
-                size_t  size() override
-                {
-                    return mMsg->size();
-                }
-
-            private:
-                std::shared_ptr<std::string>    mMsg;
-            };
-
-            send(std::make_shared<StringSendMsg>(packet), std::move(callback));
+            send(MakeStringMsg(std::move(buffer)), std::move(callback));
         }
 
         // setDataCallback(std::function<void(brynet::base::BasePacketReader&)>）

include/brynet/net/http/HttpService.hpp

@@ -32,7 +32,7 @@ namespace brynet { namespace net { namespace http {
         void                        send(PacketType&& packet,
             TcpConnection::PacketSendedCallback&& callback = nullptr)
         {
-            mSession->send(std::forward<std::shared_ptr<std::string>>(packet),
+            mSession->send(std::forward<PacketType&&>(packet),
                 std::move(callback));
         }
         void                        send(const char* packet,