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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
// 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.
#ifndef EXTENSIONS_BROWSER_API_SOCKET_TCP_SOCKET_H_
#define EXTENSIONS_BROWSER_API_SOCKET_TCP_SOCKET_H_
#include <string>
#include "extensions/browser/api/socket/socket.h"
// This looks like it should be forward-declarable, but it does some tricky
// moves that make it easier to just include it.
#include "net/socket/tcp_client_socket.h"
#include "net/socket/tcp_server_socket.h"
namespace net {
class Socket;
}
namespace extensions {
class TCPSocket : public Socket {
public:
explicit TCPSocket(const std::string& owner_extension_id);
TCPSocket(net::TCPClientSocket* tcp_client_socket,
const std::string& owner_extension_id,
bool is_connected = false);
~TCPSocket() override;
void Connect(const std::string& address,
uint16 port,
const CompletionCallback& callback) override;
void Disconnect() override;
int Bind(const std::string& address, uint16 port) override;
void Read(int count, const ReadCompletionCallback& callback) override;
void RecvFrom(int count, const RecvFromCompletionCallback& callback) override;
void SendTo(scoped_refptr<net::IOBuffer> io_buffer,
int byte_count,
const std::string& address,
uint16 port,
const CompletionCallback& callback) override;
bool SetKeepAlive(bool enable, int delay) override;
bool SetNoDelay(bool no_delay) override;
int Listen(const std::string& address,
uint16 port,
int backlog,
std::string* error_msg) override;
void Accept(const AcceptCompletionCallback& callback) override;
bool IsConnected() override;
bool GetPeerAddress(net::IPEndPoint* address) override;
bool GetLocalAddress(net::IPEndPoint* address) override;
// Like Disconnect(), only Release() doesn't delete the underlying stream
// or attempt to close it. Useful when giving away ownership with
// ClientStream().
virtual void Release();
Socket::SocketType GetSocketType() const override;
static TCPSocket* CreateSocketForTesting(
net::TCPClientSocket* tcp_client_socket,
const std::string& owner_extension_id,
bool is_connected = false);
static TCPSocket* CreateServerSocketForTesting(
net::TCPServerSocket* tcp_server_socket,
const std::string& owner_extension_id);
// Returns NULL if GetSocketType() isn't TYPE_TCP or if the connection
// wasn't set up via Connect() (vs Listen()/Accept()).
net::TCPClientSocket* ClientStream();
// Whether a Read() has been issued, that hasn't come back yet.
bool HasPendingRead() const;
protected:
int WriteImpl(net::IOBuffer* io_buffer,
int io_buffer_size,
const net::CompletionCallback& callback) override;
private:
void RefreshConnectionStatus();
void OnConnectComplete(int result);
void OnReadComplete(scoped_refptr<net::IOBuffer> io_buffer, int result);
void OnAccept(int result);
TCPSocket(net::TCPServerSocket* tcp_server_socket,
const std::string& owner_extension_id);
scoped_ptr<net::TCPClientSocket> socket_;
scoped_ptr<net::TCPServerSocket> server_socket_;
enum SocketMode { UNKNOWN = 0, CLIENT, SERVER, };
SocketMode socket_mode_;
CompletionCallback connect_callback_;
ReadCompletionCallback read_callback_;
scoped_ptr<net::StreamSocket> accept_socket_;
AcceptCompletionCallback accept_callback_;
};
// TCP Socket instances from the "sockets.tcp" namespace. These are regular
// socket objects with additional properties related to the behavior defined in
// the "sockets.tcp" namespace.
class ResumableTCPSocket : public TCPSocket {
public:
explicit ResumableTCPSocket(const std::string& owner_extension_id);
explicit ResumableTCPSocket(net::TCPClientSocket* tcp_client_socket,
const std::string& owner_extension_id,
bool is_connected);
// Overriden from ApiResource
bool IsPersistent() const override;
const std::string& name() const { return name_; }
void set_name(const std::string& name) { name_ = name; }
bool persistent() const { return persistent_; }
void set_persistent(bool persistent) { persistent_ = persistent; }
int buffer_size() const { return buffer_size_; }
void set_buffer_size(int buffer_size) { buffer_size_ = buffer_size; }
bool paused() const { return paused_; }
void set_paused(bool paused) { paused_ = paused; }
private:
friend class ApiResourceManager<ResumableTCPSocket>;
static const char* service_name() { return "ResumableTCPSocketManager"; }
// Application-defined string - see sockets_tcp.idl.
std::string name_;
// Flag indicating whether the socket is left open when the application is
// suspended - see sockets_tcp.idl.
bool persistent_;
// The size of the buffer used to receive data - see sockets_tcp.idl.
int buffer_size_;
// Flag indicating whether a connected socket blocks its peer from sending
// more data - see sockets_tcp.idl.
bool paused_;
};
// TCP Socket instances from the "sockets.tcpServer" namespace. These are
// regular socket objects with additional properties related to the behavior
// defined in the "sockets.tcpServer" namespace.
class ResumableTCPServerSocket : public TCPSocket {
public:
explicit ResumableTCPServerSocket(const std::string& owner_extension_id);
// Overriden from ApiResource
bool IsPersistent() const override;
const std::string& name() const { return name_; }
void set_name(const std::string& name) { name_ = name; }
bool persistent() const { return persistent_; }
void set_persistent(bool persistent) { persistent_ = persistent; }
bool paused() const { return paused_; }
void set_paused(bool paused) { paused_ = paused; }
private:
friend class ApiResourceManager<ResumableTCPServerSocket>;
static const char* service_name() {
return "ResumableTCPServerSocketManager";
}
// Application-defined string - see sockets_tcp_server.idl.
std::string name_;
// Flag indicating whether the socket is left open when the application is
// suspended - see sockets_tcp_server.idl.
bool persistent_;
// Flag indicating whether a connected socket blocks its peer from sending
// more data - see sockets_tcp_server.idl.
bool paused_;
};
} // namespace extensions
#endif // EXTENSIONS_BROWSER_API_SOCKET_TCP_SOCKET_H_
|
