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

extensions/browser/api/sockets_tcp/sockets_tcp_api.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 <hash_set>

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

Thanks for adding this :)  But it should be "base/containers/hash_tables.h" (and
down below with chromium headers)

+#include <string>
+#include <vector>
+
 #include "extensions/browser/api/sockets_tcp/sockets_tcp_api.h"
 
 #include "content/public/browser/browser_context.h"
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/socket/tls_socket.h"
 #include "extensions/browser/api/sockets_tcp/tcp_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 135 matching lines @@
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = sockets_tcp::Update::Results::Create();
 }
 
 SocketsTcpSetPausedFunction::SocketsTcpSetPausedFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(NULL), defer_completion_(false) {}
 
 SocketsTcpSetPausedFunction::~SocketsTcpSetPausedFunction() {}
 
 bool SocketsTcpSetPausedFunction::Prepare() {
   params_ = api::sockets_tcp::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = TCPSocketEventDispatcher::Get(browser_context());
   DCHECK(socket_event_dispatcher_)
       << "There is no socket event dispatcher. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "TCPSocketEventDispatcher.";
   return socket_event_dispatcher_ != NULL;
 }
 
 void SocketsTcpSetPausedFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   if (socket->paused() != params_->paused) {
     socket->set_paused(params_->paused);
+    // If this is a client socket, we can delay the callback's invocation
+    // until the socket is really paused.
+    BufferingTCPClientSocket* client_sock = socket->ClientStream();
+    if (client_sock && params_->paused) {
+      // Don't automatically call AsyncWorkCompleted() when Work() returns.
+      defer_completion_ = true;
+      socket->set_api_pause_complete_callback(
+          base::Bind(&SocketsTcpSetPausedFunction::AsyncWorkCompleted, this));
+      client_sock->Pause();

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

How about just making Pause take a callback? Or if that's too annoying (i.e. too
many existing callsites to update), how about introducing a PauseAsync call
which takes a callback?

+    }
     if (socket->IsConnected() && !params_->paused) {
       socket_event_dispatcher_->OnSocketResume(extension_->id(),
                                                params_->socket_id);
     }
   }
 
   results_ = sockets_tcp::SetPaused::Results::Create();
 }
 
+void SocketsTcpSetPausedFunction::AsyncWorkStart() {
+  Work();
+  if (!defer_completion_) {
+    AsyncWorkCompleted();
+  }
+}
+
 SocketsTcpSetKeepAliveFunction::SocketsTcpSetKeepAliveFunction() {}
 
 SocketsTcpSetKeepAliveFunction::~SocketsTcpSetKeepAliveFunction() {}
 
 bool SocketsTcpSetKeepAliveFunction::Prepare() {
   params_ = api::sockets_tcp::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
@@ skipping 332 matching lines @@
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::sockets_tcp::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace api
 }  // namespace extensions