A change for the setPause() api in chrome.sockets.tcp:

extensions/browser/api/socket/tls_socket.cc

 // Copyright 2014 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 "extensions/browser/api/socket/tls_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "extensions/browser/api/api_resource.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "url/url_canon.h"
 
+using extensions::BufferingStreamSocket;
+
 namespace {
 
 // Returns the SSL protocol version (as a uint16) represented by a string.
 // Returns 0 if the string is invalid.
 uint16 SSLProtocolVersionFromString(const std::string& version_str) {
   uint16 version = 0;  // Invalid.
   if (version_str == "tls1") {
     version = net::SSL_PROTOCOL_VERSION_TLS1;
   } else if (version_str == "tls1.1") {
     version = net::SSL_PROTOCOL_VERSION_TLS1_1;
   } else if (version_str == "tls1.2") {
     version = net::SSL_PROTOCOL_VERSION_TLS1_2;
   }
   return version;
 }
 
 void TlsConnectDone(scoped_ptr<net::SSLClientSocket> ssl_socket,
                     const std::string& extension_id,
                     const extensions::TLSSocket::SecureCallback& callback,
                     int result) {
   DVLOG(1) << "Got back result " << result << " " << net::ErrorToString(result);
 
   // No matter how the TLS connection attempt went, the underlying socket's
   // no longer bound to the original TCPSocket. It belongs to |ssl_socket|,
   // which is promoted here to a new API-accessible socket (via a TLSSocket
   // wrapper), or deleted.
   if (result != net::OK) {
     callback.Run(scoped_ptr<extensions::TLSSocket>(), result);
     return;
-  };
+  }
 
+  // Wrap the StreamSocket in a BufferingTCPSocket, to support SetPaused().

[Ken Rockot(use gerrit already), 2015/12/15 17:17:49]

nit: s/BufferingTCPSocket/BufferingStreamSocket/

+  scoped_ptr<BufferingStreamSocket> buffer_sock(

[Ken Rockot(use gerrit already), 2015/12/15 17:17:49]

nit: buffer_socket? No real value in abbreviating here

+      new BufferingStreamSocket(ssl_socket.Pass()));
   // Wrap the StreamSocket in a TLSSocket, which matches the extension socket
   // API. Set the handle of the socket to the new value, so that it can be
   // used for read/write/close/etc.
   scoped_ptr<extensions::TLSSocket> wrapper(
-      new extensions::TLSSocket(ssl_socket.Pass(), extension_id));
+      new extensions::TLSSocket(buffer_sock.Pass(), extension_id));
 
   // Caller will end up deleting the prior TCPSocket, once it calls
   // SetSocket(..,wrapper).
   callback.Run(wrapper.Pass(), result);
 }
 
 }  // namespace
 
 namespace extensions {
 
 const char kTLSSocketTypeInvalidError[] =
     "Cannot listen on a socket that is already connected.";
 
-TLSSocket::TLSSocket(scoped_ptr<net::StreamSocket> tls_socket,
+TLSSocket::TLSSocket(scoped_ptr<BufferingStreamSocket> tls_socket,
                      const std::string& owner_extension_id)
-    : ResumableTCPSocket(owner_extension_id), tls_socket_(tls_socket.Pass()) {
-}
+    : ResumableTCPSocket(owner_extension_id), tls_socket_(tls_socket.Pass()) {}
 
 TLSSocket::~TLSSocket() {
   Disconnect();
 }
 
 void TLSSocket::Connect(const net::AddressList& address,
                         const CompletionCallback& callback) {
   callback.Run(net::ERR_CONNECTION_FAILED);
 }
 
@@ skipping 140 matching lines @@
   }
 
   net::HostPortPair host_and_port(canon_host, dest_host_port_pair.port());
 
   scoped_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
 
   // Set the socket handle to the socket's client stream (that should be the
   // only one active here). Then have the old socket release ownership on
   // that client stream.
+  tcp_socket->ClientStream()->DisableBuffering();
   socket_handle->SetSocket(
       scoped_ptr<net::StreamSocket>(tcp_socket->ClientStream()));
   tcp_socket->Release();
 
   DCHECK(transport_security_state);
   net::SSLClientSocketContext context;
   context.cert_verifier = cert_verifier;
   context.transport_security_state = transport_security_state;
 
   // Fill in the SSL socket params.
@@ skipping 52 matching lines @@
     // fail with an error above.
     if (status != net::OK) {
       DVLOG(1) << "Status is not OK or IO-pending: "
                << net::ErrorToString(status);
     }
     connect_cb.Run(status);
   }
 }
 
 }  // namespace extensions
-