1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "extensions/browser/api/socket/socket.h"
6
7 #include "base/bind.h"
8 #include "base/lazy_instance.h"
9 #include "extensions/browser/api/api_resource_manager.h"
10 #include "net/base/address_list.h"
11 #include "net/base/io_buffer.h"
12 #include "net/base/ip_endpoint.h"
13 #include "net/base/net_errors.h"
14 #include "net/socket/socket.h"
15
16 namespace extensions {
17
18 const char kSocketTypeNotSupported[] = "Socket type does not support this API";
19
20 static base::LazyInstance<
21 BrowserContextKeyedAPIFactory<ApiResourceManager<Socket> > > g_factory =
22 LAZY_INSTANCE_INITIALIZER;
23
24 // static
25 template <>
26 BrowserContextKeyedAPIFactory<ApiResourceManager<Socket> >*
GetFactoryInstance()27 ApiResourceManager<Socket>::GetFactoryInstance() {
28 return g_factory.Pointer();
29 }
30
Socket(const std::string & owner_extension_id)31 Socket::Socket(const std::string& owner_extension_id)
32 : ApiResource(owner_extension_id), is_connected_(false) {}
33
~Socket()34 Socket::~Socket() {
35 // Derived destructors should make sure the socket has been closed.
36 DCHECK(!is_connected_);
37 }
38
Write(scoped_refptr<net::IOBuffer> io_buffer,int byte_count,const CompletionCallback & callback)39 void Socket::Write(scoped_refptr<net::IOBuffer> io_buffer,
40 int byte_count,
41 const CompletionCallback& callback) {
42 DCHECK(!callback.is_null());
43 write_queue_.push(WriteRequest(io_buffer, byte_count, callback));
44 WriteData();
45 }
46
WriteData()47 void Socket::WriteData() {
48 // IO is pending.
49 if (io_buffer_write_.get())
50 return;
51
52 WriteRequest& request = write_queue_.front();
53
54 DCHECK(request.byte_count >= request.bytes_written);
55 io_buffer_write_ = new net::WrappedIOBuffer(request.io_buffer->data() +
56 request.bytes_written);
57 int result =
58 WriteImpl(io_buffer_write_.get(),
59 request.byte_count - request.bytes_written,
60 base::Bind(&Socket::OnWriteComplete, base::Unretained(this)));
61
62 if (result != net::ERR_IO_PENDING)
63 OnWriteComplete(result);
64 }
65
OnWriteComplete(int result)66 void Socket::OnWriteComplete(int result) {
67 io_buffer_write_ = NULL;
68
69 WriteRequest& request = write_queue_.front();
70
71 if (result >= 0) {
72 request.bytes_written += result;
73 if (request.bytes_written < request.byte_count) {
74 WriteData();
75 return;
76 }
77 DCHECK(request.bytes_written == request.byte_count);
78 result = request.bytes_written;
79 }
80
81 request.callback.Run(result);
82 write_queue_.pop();
83
84 if (!write_queue_.empty())
85 WriteData();
86 }
87
SetKeepAlive(bool enable,int delay)88 bool Socket::SetKeepAlive(bool enable, int delay) { return false; }
89
SetNoDelay(bool no_delay)90 bool Socket::SetNoDelay(bool no_delay) { return false; }
91
Listen(const std::string & address,int port,int backlog,std::string * error_msg)92 int Socket::Listen(const std::string& address,
93 int port,
94 int backlog,
95 std::string* error_msg) {
96 *error_msg = kSocketTypeNotSupported;
97 return net::ERR_FAILED;
98 }
99
Accept(const AcceptCompletionCallback & callback)100 void Socket::Accept(const AcceptCompletionCallback& callback) {
101 callback.Run(net::ERR_FAILED, NULL);
102 }
103
104 // static
StringAndPortToIPEndPoint(const std::string & ip_address_str,int port,net::IPEndPoint * ip_end_point)105 bool Socket::StringAndPortToIPEndPoint(const std::string& ip_address_str,
106 int port,
107 net::IPEndPoint* ip_end_point) {
108 DCHECK(ip_end_point);
109 net::IPAddressNumber ip_number;
110 if (!net::ParseIPLiteralToNumber(ip_address_str, &ip_number))
111 return false;
112
113 *ip_end_point = net::IPEndPoint(ip_number, port);
114 return true;
115 }
116
StringAndPortToAddressList(const std::string & ip_address_str,int port,net::AddressList * address_list)117 bool Socket::StringAndPortToAddressList(const std::string& ip_address_str,
118 int port,
119 net::AddressList* address_list) {
120 DCHECK(address_list);
121 net::IPAddressNumber ip_number;
122 if (!net::ParseIPLiteralToNumber(ip_address_str, &ip_number))
123 return false;
124
125 *address_list = net::AddressList::CreateFromIPAddress(ip_number, port);
126 return true;
127 }
128
IPEndPointToStringAndPort(const net::IPEndPoint & address,std::string * ip_address_str,int * port)129 void Socket::IPEndPointToStringAndPort(const net::IPEndPoint& address,
130 std::string* ip_address_str,
131 int* port) {
132 DCHECK(ip_address_str);
133 DCHECK(port);
134 *ip_address_str = address.ToStringWithoutPort();
135 if (ip_address_str->empty()) {
136 *port = 0;
137 } else {
138 *port = address.port();
139 }
140 }
141
WriteRequest(scoped_refptr<net::IOBuffer> io_buffer,int byte_count,const CompletionCallback & callback)142 Socket::WriteRequest::WriteRequest(scoped_refptr<net::IOBuffer> io_buffer,
143 int byte_count,
144 const CompletionCallback& callback)
145 : io_buffer(io_buffer),
146 byte_count(byte_count),
147 callback(callback),
148 bytes_written(0) {}
149
~WriteRequest()150 Socket::WriteRequest::~WriteRequest() {}
151
152 } // namespace extensions
153