PseudoTcp to expose settings of nagling and ACK delay

jingle/glue/pseudotcp_adapter.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "jingle/glue/pseudotcp_adapter.h"
 
 #include "base/logging.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
@@ skipping 28 matching lines @@
   // cricket::IPseudoTcpNotify interface.
   // These notifications are triggered from NotifyPacket.
   virtual void OnTcpOpen(cricket::PseudoTcp* tcp) OVERRIDE;
   virtual void OnTcpReadable(cricket::PseudoTcp* tcp) OVERRIDE;
   virtual void OnTcpWriteable(cricket::PseudoTcp* tcp) OVERRIDE;
   // This is triggered by NotifyClock or NotifyPacket.
   virtual void OnTcpClosed(cricket::PseudoTcp* tcp, uint32 error) OVERRIDE;
   // This is triggered by NotifyClock, NotifyPacket, Recv and Send.
   virtual WriteResult TcpWritePacket(cricket::PseudoTcp* tcp,
                                      const char* buffer, size_t len) OVERRIDE;
+
+  void SetAckDelay(int delay_ms);
+  void SetNagling(bool nagling);
+
  private:
   // These are invoked by the underlying Socket, and may trigger callbacks.
   // They hold a reference to |this| while running, to protect from deletion.
   void OnRead(int result);
   void OnWritten(int result);
 
   // These may trigger callbacks, so the holder must hold a reference on
   // the stack while calling them.
   void DoReadFromSocket();
   void HandleReadResults(int result);
@@ skipping 203 matching lines @@
     callback->Run(net::MapSystemError(error));
   }
 
   if (write_callback_) {
     net::CompletionCallback* callback = write_callback_;
     write_callback_ = NULL;
     callback->Run(net::MapSystemError(error));
   }
 }
 
+void PseudoTcpAdapter::Core::SetAckDelay(int delay_ms) {
+  pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_ACKDELAY, delay_ms);
+}
+
+void PseudoTcpAdapter::Core::SetNagling(bool nagling) {
+  pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_NODELAY, nagling ? 1 : 0);
+}
+
 cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
     PseudoTcp* tcp,
     const char* buffer,
     size_t len) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
 
   // If we already have a write pending, we behave like a congested network,
   // returning success for the write, but dropping the packet.  PseudoTcp will
   // back-off and retransmit, adjusting for the perceived congestion.
   if (socket_write_pending_)
@@ skipping 184 matching lines @@
 int64 PseudoTcpAdapter::NumBytesRead() const {
   DCHECK(CalledOnValidThread());
   return -1;
 }
 
 base::TimeDelta PseudoTcpAdapter::GetConnectTimeMicros() const {
   DCHECK(CalledOnValidThread());
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
+void PseudoTcpAdapter::SetAckDelay(int delay_ms) {
+  DCHECK(CalledOnValidThread());
+  core_->SetAckDelay(delay_ms);
+}
+
+void PseudoTcpAdapter::SetNagling(bool nagling) {
+  DCHECK(CalledOnValidThread());
+  core_->SetNagling(nagling);
+}
+
 }  // namespace jingle_glue