• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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