extensions/browser/api/socket/udp_socket.h

   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 #ifndef EXTENSIONS_BROWSER_API_SOCKET_UDP_SOCKET_H_
   6 #define EXTENSIONS_BROWSER_API_SOCKET_UDP_SOCKET_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "extensions/browser/api/socket/socket.h"
  12 #include "net/udp/udp_socket.h"
  13
  14 namespace extensions {
  15
  16 class UDPSocket : public Socket {
  17  public:
  18   explicit UDPSocket(const std::string& owner_extension_id);
  19   ~UDPSocket() override;
  20
  21   void Connect(const std::string& address,
  22                uint16 port,
  23                const CompletionCallback& callback) override;
  24   void Disconnect() override;
  25   int Bind(const std::string& address, uint16 port) override;
  26   void Read(int count, const ReadCompletionCallback& callback) override;
  27   void RecvFrom(int count, const RecvFromCompletionCallback& callback) override;
  28   void SendTo(scoped_refptr<net::IOBuffer> io_buffer,
  29               int byte_count,
  30               const std::string& address,
  31               uint16 port,
  32               const CompletionCallback& callback) override;
  33
  34   bool IsConnected() override;
  35
  36   bool GetPeerAddress(net::IPEndPoint* address) override;
  37   bool GetLocalAddress(net::IPEndPoint* address) override;
  38   Socket::SocketType GetSocketType() const override;
  39
  40   bool IsBound();
  41
  42   int JoinGroup(const std::string& address);
  43   int LeaveGroup(const std::string& address);
  44
  45   int SetMulticastTimeToLive(int ttl);
  46   int SetMulticastLoopbackMode(bool loopback);
  47
  48   int SetBroadcast(bool enabled);
  49
  50   const std::vector<std::string>& GetJoinedGroups() const;
  51
  52  protected:
  53   int WriteImpl(net::IOBuffer* io_buffer,
  54                 int io_buffer_size,
  55                 const net::CompletionCallback& callback) override;
  56
  57  private:
  58   // Make net::IPEndPoint can be refcounted
  59   typedef base::RefCountedData<net::IPEndPoint> IPEndPoint;
  60
  61   void OnReadComplete(scoped_refptr<net::IOBuffer> io_buffer, int result);
  62   void OnRecvFromComplete(scoped_refptr<net::IOBuffer> io_buffer,
  63                           scoped_refptr<IPEndPoint> address,
  64                           int result);
  65   void OnSendToComplete(int result);
  66
  67   net::UDPSocket socket_;
  68
  69   ReadCompletionCallback read_callback_;
  70
  71   RecvFromCompletionCallback recv_from_callback_;
  72
  73   CompletionCallback send_to_callback_;
  74
  75   std::vector<std::string> multicast_groups_;
  76 };
  77
  78 // UDP Socket instances from the "sockets.udp" namespace. These are regular
  79 // socket objects with additional properties related to the behavior defined in
  80 // the "sockets.udp" namespace.
  81 class ResumableUDPSocket : public UDPSocket {
  82  public:
  83   explicit ResumableUDPSocket(const std::string& owner_extension_id);
  84
  85   // Overriden from ApiResource
  86   bool IsPersistent() const override;
  87
  88   const std::string& name() const { return name_; }
  89   void set_name(const std::string& name) { name_ = name; }
  90
  91   bool persistent() const { return persistent_; }
  92   void set_persistent(bool persistent) { persistent_ = persistent; }
  93
  94   int buffer_size() const { return buffer_size_; }
  95   void set_buffer_size(int buffer_size) { buffer_size_ = buffer_size; }
  96
  97   bool paused() const { return paused_; }
  98   void set_paused(bool paused) { paused_ = paused; }
  99
 100  private:
 101   friend class ApiResourceManager<ResumableUDPSocket>;
 102   static const char* service_name() { return "ResumableUDPSocketManager"; }
 103
 104   // Application-defined string - see sockets_udp.idl.
 105   std::string name_;
 106   // Flag indicating whether the socket is left open when the application is
 107   // suspended - see sockets_udp.idl.
 108   bool persistent_;
 109   // The size of the buffer used to receive data - see sockets_udp.idl.
 110   int buffer_size_;
 111   // Flag indicating whether a connected socket blocks its peer from sending
 112   // more data - see sockets_udp.idl.
 113   bool paused_;
 114 };
 115
 116 }  //  namespace extensions
 117
 118 #endif  // EXTENSIONS_BROWSER_API_SOCKET_UDP_SOCKET_H_