1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright (c) 2010 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.
#ifndef NET_SOCKET_TCP_CLIENT_SOCKET_WIN_H_
#define NET_SOCKET_TCP_CLIENT_SOCKET_WIN_H_
#pragma once
#include <winsock2.h>
#include "base/non_thread_safe.h"
#include "base/object_watcher.h"
#include "net/base/address_list.h"
#include "net/base/completion_callback.h"
#include "net/base/net_log.h"
#include "net/socket/client_socket.h"
namespace net {
class BoundNetLog;
class TCPClientSocketWin : public ClientSocket, NonThreadSafe {
public:
// The IP address(es) and port number to connect to. The TCP socket will try
// each IP address in the list until it succeeds in establishing a
// connection.
TCPClientSocketWin(const AddressList& addresses,
net::NetLog* net_log,
const net::NetLog::Source& source);
virtual ~TCPClientSocketWin();
// AdoptSocket causes the given, connected socket to be adopted as a TCP
// socket. This object must not be connected. This object takes ownership of
// the given socket and then acts as if Connect() had been called. This
// function is intended for testing only.
void AdoptSocket(SOCKET socket);
// ClientSocket methods:
virtual int Connect(CompletionCallback* callback
#ifdef ANDROID
, bool wait_for_connect
#endif
);
virtual void Disconnect();
virtual bool IsConnected() const;
virtual bool IsConnectedAndIdle() const;
virtual int GetPeerAddress(AddressList* address) const;
virtual const BoundNetLog& NetLog() const { return net_log_; }
virtual void SetSubresourceSpeculation();
virtual void SetOmniboxSpeculation();
virtual bool WasEverUsed() const;
virtual bool UsingTCPFastOpen() const;
// Socket methods:
// Multiple outstanding requests are not supported.
// Full duplex mode (reading and writing at the same time) is supported
virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback);
virtual bool SetReceiveBufferSize(int32 size);
virtual bool SetSendBufferSize(int32 size);
private:
// State machine for connecting the socket.
enum ConnectState {
CONNECT_STATE_CONNECT,
CONNECT_STATE_CONNECT_COMPLETE,
CONNECT_STATE_NONE,
};
class Core;
// State machine used by Connect().
int DoConnectLoop(int result);
int DoConnect();
int DoConnectComplete(int result);
// Helper used by Disconnect(), which disconnects minus the logging and
// resetting of current_ai_.
void DoDisconnect();
// Returns true if a Connect() is in progress.
bool waiting_connect() const {
return next_connect_state_ != CONNECT_STATE_NONE;
}
// Returns the OS error code (or 0 on success).
int CreateSocket(const struct addrinfo* ai);
// Returns the OS error code (or 0 on success).
int SetupSocket();
// Called after Connect() has completed with |net_error|.
void LogConnectCompletion(int net_error);
void DoReadCallback(int rv);
void DoWriteCallback(int rv);
void DidCompleteConnect();
void DidCompleteRead();
void DidCompleteWrite();
SOCKET socket_;
// The list of addresses we should try in order to establish a connection.
AddressList addresses_;
// Where we are in above list, or NULL if all addrinfos have been tried.
const struct addrinfo* current_ai_;
// The various states that the socket could be in.
bool waiting_read_;
bool waiting_write_;
// The core of the socket that can live longer than the socket itself. We pass
// resources to the Windows async IO functions and we have to make sure that
// they are not destroyed while the OS still references them.
scoped_refptr<Core> core_;
// External callback; called when connect or read is complete.
CompletionCallback* read_callback_;
// External callback; called when write is complete.
CompletionCallback* write_callback_;
// The next state for the Connect() state machine.
ConnectState next_connect_state_;
// The OS error that CONNECT_STATE_CONNECT last completed with.
int connect_os_error_;
BoundNetLog net_log_;
// This socket was previously disconnected and has not been re-connected.
bool previously_disconnected_;
// Record of connectivity and transmissions, for use in speculative connection
// histograms.
UseHistory use_history_;
DISALLOW_COPY_AND_ASSIGN(TCPClientSocketWin);
};
} // namespace net
#endif // NET_SOCKET_TCP_CLIENT_SOCKET_WIN_H_
|
