Migrates QUIC sessions to a new network when old network is (about to be) disconnected.

net/socket/socket_test_util.cc

 // Copyright (c) 2012 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/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_failure_state.h"
 #include "net/ssl/ssl_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define NET_TRACE(level, s) VLOG(level) << s << __FUNCTION__ << "() "
 
 namespace net {
 
+NET_EXPORT NetworkChangeNotifier::NetworkHandle kDefaultNetworkForTests = 1;
+NET_EXPORT NetworkChangeNotifier::NetworkHandle kNewNetworkForTests = 2;

[Ryan Hamilton, 2015/12/29 05:29:36]

Is this used?

[Jana, 2016/01/06 23:01:17]

It's used in the tests, but I declared it here with the other constant for
context.

+
 namespace {
 
 inline char AsciifyHigh(char x) {
   char nybble = static_cast<char>((x >> 4) & 0x0F);
   return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10);
 }
 
 inline char AsciifyLow(char x) {
   char nybble = static_cast<char>((x >> 0) & 0x0F);
   return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10);
@@ skipping 1188 matching lines @@
 }
 
 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
       read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       source_port_(123),
+      network_(NetworkChangeNotifier::kInvalidNetworkHandle),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_NONE)),
       weak_factory_(this) {
   DCHECK(data_);
   data_->Initialize(this);
   peer_addr_ = data->connect_data().peer_addr;
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {
@@ skipping 78 matching lines @@
   *address = IPEndPoint(ip, source_port_);
   return OK;
 }
 
 const BoundNetLog& MockUDPClientSocket::NetLog() const {
   return net_log_;
 }
 
 int MockUDPClientSocket::BindToNetwork(
     NetworkChangeNotifier::NetworkHandle network) {
-  return ERR_NOT_IMPLEMENTED;
+  network_ = network;
+  return OK;
 }
 
 int MockUDPClientSocket::BindToDefaultNetwork() {
-  return ERR_NOT_IMPLEMENTED;
+  network_ = kDefaultNetworkForTests;
+  return OK;
 }
 
 NetworkChangeNotifier::NetworkHandle MockUDPClientSocket::GetBoundNetwork()
     const {
-  return NetworkChangeNotifier::kInvalidNetworkHandle;
+  return network_;
 }
 
 int MockUDPClientSocket::Connect(const IPEndPoint& address) {
   if (!data_)
     return ERR_UNEXPECTED;
   connected_ = true;
   peer_addr_ = address;
   return data_->connect_data().result;
 }
 
@@ skipping 332 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net