Move fail on suspend logic from URLRequestJob to TcpClientSocket.

net/socket/tcp_client_socket.cc

 // Copyright (c) 2013 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 "net/socket/tcp_client_socket.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket_performance_watcher.h"
 
+#if !defined(OS_NACL)
+#include "base/power_monitor/power_monitor.h"
+#endif
+
 namespace net {
 
 class NetLogWithSource;
 
 TCPClientSocket::TCPClientSocket(
     const AddressList& addresses,
     std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     net::NetLog* net_log,
     const net::NetLogSource& source)
     : socket_performance_watcher_(socket_performance_watcher.get()),
       socket_(new TCPSocket(std::move(socket_performance_watcher),
                             net_log,
                             source)),
       addresses_(addresses),
       current_address_index_(-1),
       next_connect_state_(CONNECT_STATE_NONE),
       previously_disconnected_(false),
-      total_received_bytes_(0) {}
+      total_received_bytes_(0),
+      weak_ptr_factory_(this) {}
 
 TCPClientSocket::TCPClientSocket(std::unique_ptr<TCPSocket> connected_socket,
                                  const IPEndPoint& peer_address)
     : socket_performance_watcher_(nullptr),
       socket_(std::move(connected_socket)),
       addresses_(AddressList(peer_address)),
       current_address_index_(0),
       next_connect_state_(CONNECT_STATE_NONE),
       previously_disconnected_(false),
-      total_received_bytes_(0) {
+      total_received_bytes_(0),
+      weak_ptr_factory_(this) {
   DCHECK(socket_);
 
   socket_->SetDefaultOptionsForClient();
   use_history_.set_was_ever_connected();
 }
 
 TCPClientSocket::~TCPClientSocket() {
+  SetFailOnSuspend(false);
   Disconnect();
 }
 
 int TCPClientSocket::Bind(const IPEndPoint& address) {
   if (current_address_index_ >= 0 || bind_address_) {
     // Cannot bind the socket if we are already connected or connecting.
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
@@ skipping 12 matching lines @@
   return OK;
 }
 
 int TCPClientSocket::Connect(const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   // If connecting or already connected, then just return OK.
   if (socket_->IsValid() && current_address_index_ >= 0)
     return OK;
 
+  was_disconnected_on_suspend_ = false;
+
   socket_->StartLoggingMultipleConnectAttempts(addresses_);
 
   // We will try to connect to each address in addresses_. Start with the
   // first one in the list.
   next_connect_state_ = CONNECT_STATE_CONNECT;
   current_address_index_ = 0;
 
   int rv = DoConnectLoop(OK);
   if (rv == ERR_IO_PENDING) {
     connect_callback_ = callback;
@@ skipping 117 matching lines @@
   }
 
   // Otherwise there is nothing to fall back to, so give up.
   return result;
 }
 
 void TCPClientSocket::Disconnect() {
   DoDisconnect();
   current_address_index_ = -1;
   bind_address_.reset();
+
+  // Cancel any pending callbacks. Not done in Disconnect() because that's
+  // called on connection failure, when the connect callback will need to be
+  // invoked.
+  was_disconnected_on_suspend_ = false;
+  connect_callback_.Reset();
+  read_callback_.Reset();
+  write_callback_.Reset();
 }
 
 void TCPClientSocket::DoDisconnect() {
   total_received_bytes_ = 0;
   EmitTCPMetricsHistogramsOnDisconnect();
   // If connecting or already connected, record that the socket has been
   // disconnected.
   previously_disconnected_ = socket_->IsValid() && current_address_index_ >= 0;
   socket_->Close();
+
+  // Invalidate weak pointers, so if in the middle of a callback in OnSuspend,
+  // and something destroys this, no other callback is invoked.
+  weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool TCPClientSocket::IsConnected() const {
   return socket_->IsConnected();
 }
 
 bool TCPClientSocket::IsConnectedAndIdle() const {
   return socket_->IsConnectedAndIdle();
 }
 
@@ skipping 40 matching lines @@
 }
 
 NextProto TCPClientSocket::GetNegotiatedProtocol() const {
   return kProtoUnknown;
 }
 
 bool TCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
+void TCPClientSocket::SetFailOnSuspend(bool disconnect_on_suspend) {
+// Do nothing if building under NaCl.
+#if !defined(OS_NACL)
+  // Do nothing if state is unchanged.
+  if (disconnect_on_suspend_ == disconnect_on_suspend)
+    return;
+
+  // Otherwise, start/stop observing if there's a PowerMonitor configured, as
+  // needed.
+  base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
+  if (!power_monitor)
+    return;
+  disconnect_on_suspend_ = disconnect_on_suspend;
+  if (disconnect_on_suspend_) {
+    power_monitor->AddObserver(this);
+  } else {
+    power_monitor->RemoveObserver(this);
+  }
+#endif  // !defined(OS_NACL)
+}
+
 int TCPClientSocket::Read(IOBuffer* buf,
                           int buf_len,
                           const CompletionCallback& callback) {
   return ReadCommon(buf, buf_len, callback, /*read_if_ready=*/false);
 }
 
 int TCPClientSocket::ReadIfReady(IOBuffer* buf,
                                  int buf_len,
                                  const CompletionCallback& callback) {
   return ReadCommon(buf, buf_len, callback, /*read_if_ready=*/true);
 }
 
 int TCPClientSocket::Write(IOBuffer* buf,
                            int buf_len,
                            const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
+  DCHECK(write_callback_.is_null());
 
   // |socket_| is owned by this class and the callback won't be run once
   // |socket_| is gone. Therefore, it is safe to use base::Unretained() here.
-  CompletionCallback write_callback = base::Bind(
-      &TCPClientSocket::DidCompleteWrite, base::Unretained(this), callback);
+  CompletionCallback write_callback =
+      base::Bind(&TCPClientSocket::DidCompleteWrite, base::Unretained(this));
   int result = socket_->Write(buf, buf_len, write_callback);
-  if (result > 0)
+  if (result == ERR_IO_PENDING) {
+    write_callback_ = callback;
+  } else if (result > 0) {
     use_history_.set_was_used_to_convey_data();
+  }
 
   return result;
 }
 
 int TCPClientSocket::SetReceiveBufferSize(int32_t size) {
   return socket_->SetReceiveBufferSize(size);
 }
 
 int TCPClientSocket::SetSendBufferSize(int32_t size) {
-    return socket_->SetSendBufferSize(size);
+  return socket_->SetSendBufferSize(size);
 }
 
 bool TCPClientSocket::SetKeepAlive(bool enable, int delay) {
   return socket_->SetKeepAlive(enable, delay);
 }
 
 bool TCPClientSocket::SetNoDelay(bool no_delay) {
   return socket_->SetNoDelay(no_delay);
 }
 
 void TCPClientSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
   *out = connection_attempts_;
 }
 
 void TCPClientSocket::ClearConnectionAttempts() {
   connection_attempts_.clear();
 }
 
 void TCPClientSocket::AddConnectionAttempts(
     const ConnectionAttempts& attempts) {
   connection_attempts_.insert(connection_attempts_.begin(), attempts.begin(),
                               attempts.end());
 }
 
 int64_t TCPClientSocket::GetTotalReceivedBytes() const {
   return total_received_bytes_;
 }
 
+void TCPClientSocket::OnSuspend() {
+  // If the socket is connected, or connecting, act as if current and future
+  // operations on the socket fail with ERR_NETWORK_IO_SUSPENDED, until the
+  // socket is reconnected.
+  // TODO(mmenke):  This doesn't cover sockets created after OnSuspend runs,
+  // just before suspend mode starts. Would it make more sense to do this on
+  // resume?
+
+  if (next_connect_state_ != CONNECT_STATE_NONE) {
+    DidCompleteConnect(ERR_NETWORK_IO_SUSPENDED);
+    return;
+  }
+
+  // Nothing to do.
+  if (!IsConnected())
+    return;
+
+  Disconnect();
+
+  was_disconnected_on_suspend_ = true;
+
+  // Grab a weap pointer just in case calling read callback results in |this|
+  // being destroyed, or disconnected. In either case, should not run the write
+  // callback.
+  base::WeakPtr<TCPClientSocket> weak_this = weak_ptr_factory_.GetWeakPtr();
+
+  if (read_callback_)
+    DidCompleteRead(ERR_NETWORK_IO_SUSPENDED);
+  if (weak_this && write_callback_)
+    DidCompleteWrite(ERR_NETWORK_IO_SUSPENDED);
+}
+
 void TCPClientSocket::DidCompleteConnect(int result) {
   DCHECK_EQ(next_connect_state_, CONNECT_STATE_CONNECT_COMPLETE);
   DCHECK_NE(result, ERR_IO_PENDING);
   DCHECK(!connect_callback_.is_null());
 
   result = DoConnectLoop(result);
   if (result != ERR_IO_PENDING) {
     socket_->EndLoggingMultipleConnectAttempts(result);
     base::ResetAndReturn(&connect_callback_).Run(result);
   }
 }
 
-void TCPClientSocket::DidCompleteRead(const CompletionCallback& callback,
-                                      int result) {
+void TCPClientSocket::DidCompleteRead(int result) {
+  DCHECK(!read_callback_.is_null());
   if (result > 0)
     total_received_bytes_ += result;
 
-  DidCompleteReadWrite(callback, result);
+  DidCompleteReadWrite(base::ResetAndReturn(&read_callback_), result);
 }
 
-void TCPClientSocket::DidCompleteWrite(const CompletionCallback& callback,
-                                       int result) {
-  DidCompleteReadWrite(callback, result);
+void TCPClientSocket::DidCompleteWrite(int result) {
+  DCHECK(!write_callback_.is_null());
+  DidCompleteReadWrite(base::ResetAndReturn(&write_callback_), result);
 }
 
 void TCPClientSocket::DidCompleteReadWrite(const CompletionCallback& callback,
                                            int result) {
   if (result > 0)
     use_history_.set_was_used_to_convey_data();
 
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462780 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ skipping 16 matching lines @@
 void TCPClientSocket::EmitTCPMetricsHistogramsOnDisconnect() {
   base::TimeDelta rtt;
   if (socket_->GetEstimatedRoundTripTime(&rtt)) {
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TcpRtt.AtDisconnect", rtt,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMinutes(10), 100);
   }
 }
 
 }  // namespace net