Home | History | Annotate | Download | only in socket 
      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> >*
     27 ApiResourceManager<Socket>::GetFactoryInstance() {
     28   return g_factory.Pointer();
     29 }
     30 
     31 Socket::Socket(const std::string& owner_extension_id)
     32     : ApiResource(owner_extension_id), is_connected_(false) {}
     33 
     34 Socket::~Socket() {
     35   // Derived destructors should make sure the socket has been closed.
     36   DCHECK(!is_connected_);
     37 }
     38 
     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 
     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 
     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 
     88 bool Socket::SetKeepAlive(bool enable, int delay) { return false; }
     89 
     90 bool Socket::SetNoDelay(bool no_delay) { return false; }
     91 
     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 
    100 void Socket::Accept(const AcceptCompletionCallback& callback) {
    101   callback.Run(net::ERR_FAILED, NULL);
    102 }
    103 
    104 // static
    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 
    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 
    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 
    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 
    150 Socket::WriteRequest::~WriteRequest() {}
    151 
    152 }  // namespace extensions
    153