clang-format runtime/bin

runtime/bin/socket.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_BIN_SOCKET_H_
 #define RUNTIME_BIN_SOCKET_H_
 
 #if defined(DART_IO_DISABLED)
 #error "socket.h can only be included on builds with IO enabled"
 #endif
@@ skipping 56 matching lines @@
       return TYPE_IPV6;
     }
     return TYPE_IPV4;
   }
 
   const char* as_string() const { return as_string_; }
   const RawAddr& addr() const { return addr_; }
 
   static intptr_t GetAddrLength(const RawAddr& addr) {
     ASSERT((addr.ss.ss_family == AF_INET) || (addr.ss.ss_family == AF_INET6));
-    return (addr.ss.ss_family == AF_INET6) ?
-        sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+    return (addr.ss.ss_family == AF_INET6) ? sizeof(struct sockaddr_in6)
+                                           : sizeof(struct sockaddr_in);
   }
 
   static intptr_t GetInAddrLength(const RawAddr& addr) {
     ASSERT((addr.ss.ss_family == AF_INET) || (addr.ss.ss_family == AF_INET6));
-    return (addr.ss.ss_family == AF_INET6) ?
-        sizeof(struct in6_addr) : sizeof(struct in_addr);
+    return (addr.ss.ss_family == AF_INET6) ? sizeof(struct in6_addr)
+                                           : sizeof(struct in_addr);
   }
 
   static bool AreAddressesEqual(const RawAddr& a, const RawAddr& b) {
     if (a.ss.ss_family == AF_INET) {
       if (b.ss.ss_family != AF_INET) {
         return false;
       }
       return memcmp(&a.in.sin_addr, &b.in.sin_addr, sizeof(a.in.sin_addr)) == 0;
     } else if (a.ss.ss_family == AF_INET6) {
       if (b.ss.ss_family != AF_INET6) {
         return false;
       }
-      return memcmp(&a.in6.sin6_addr,
-                    &b.in6.sin6_addr,
+      return memcmp(&a.in6.sin6_addr, &b.in6.sin6_addr,
                     sizeof(a.in6.sin6_addr)) == 0;
     } else {
       UNREACHABLE();
       return false;
     }
   }
 
   static void GetSockAddr(Dart_Handle obj, RawAddr* addr) {
     Dart_TypedData_Type data_type;
     uint8_t* data = NULL;
     intptr_t len;
     Dart_Handle result = Dart_TypedDataAcquireData(
         obj, &data_type, reinterpret_cast<void**>(&data), &len);
     if (Dart_IsError(result)) {
       Dart_PropagateError(result);
     }
     if ((data_type != Dart_TypedData_kUint8) ||
         ((len != sizeof(in_addr)) && (len != sizeof(in6_addr)))) {
       Dart_PropagateError(
           Dart_NewApiError("Unexpected type for socket address"));
     }
     memset(reinterpret_cast<void*>(addr), 0, sizeof(RawAddr));
     if (len == sizeof(in_addr)) {
       addr->in.sin_family = AF_INET;
-      memmove(reinterpret_cast<void *>(&addr->in.sin_addr), data, len);
+      memmove(reinterpret_cast<void*>(&addr->in.sin_addr), data, len);
     } else {
       ASSERT(len == sizeof(in6_addr));
       addr->in6.sin6_family = AF_INET6;
       memmove(reinterpret_cast<void*>(&addr->in6.sin6_addr), data, len);
     }
     Dart_TypedDataReleaseData(obj);
   }
 
   static int16_t FromType(int type) {
     if (type == TYPE_ANY) {
@@ skipping 24 matching lines @@
 
   static Dart_Handle ToTypedData(const RawAddr& addr) {
     int len = GetInAddrLength(addr);
     Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, len);
     if (Dart_IsError(result)) {
       Dart_PropagateError(result);
     }
     Dart_Handle err;
     if (addr.addr.sa_family == AF_INET6) {
       err = Dart_ListSetAsBytes(
-          result, 0,
-          reinterpret_cast<const uint8_t*>(&addr.in6.sin6_addr), len);
+          result, 0, reinterpret_cast<const uint8_t*>(&addr.in6.sin6_addr),
+          len);
     } else {
       err = Dart_ListSetAsBytes(
           result, 0, reinterpret_cast<const uint8_t*>(&addr.in.sin_addr), len);
     }
     if (Dart_IsError(err)) {
       Dart_PropagateError(err);
     }
     return result;
   }
 
@@ skipping 21 matching lines @@
 
 class InterfaceSocketAddress {
  public:
   InterfaceSocketAddress(struct sockaddr* sa,
                          const char* interface_name,
                          intptr_t interface_index)
       : socket_address_(new SocketAddress(sa)),
         interface_name_(interface_name),
         interface_index_(interface_index) {}
 
-  ~InterfaceSocketAddress() {
-    delete socket_address_;
-  }
+  ~InterfaceSocketAddress() { delete socket_address_; }
 
   SocketAddress* socket_address() const { return socket_address_; }
   const char* interface_name() const { return interface_name_; }
   int interface_index() const { return interface_index_; }
 
  private:
   SocketAddress* socket_address_;
   const char* interface_name_;
   intptr_t interface_index_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceSocketAddress);
 };
 
 
-template<typename T>
+template <typename T>
 class AddressList {
  public:
   explicit AddressList(intptr_t count)
-      : count_(count),
-        addresses_(new T*[count_]) {}
+      : count_(count), addresses_(new T*[count_]) {}
 
   ~AddressList() {
     for (intptr_t i = 0; i < count_; i++) {
       delete addresses_[i];
     }
     delete[] addresses_;
   }
 
   intptr_t count() const { return count_; }
   T* GetAt(intptr_t i) const { return addresses_[i]; }
@@ skipping 15 matching lines @@
     kReverseLookupRequest = 2,
   };
 
   static bool Initialize();
   static intptr_t Available(intptr_t fd);
   static intptr_t Read(intptr_t fd, void* buffer, intptr_t num_bytes);
   static intptr_t Write(intptr_t fd, const void* buffer, intptr_t num_bytes);
   // Send data on a socket. The port to send to is specified in the port
   // component of the passed RawAddr structure. The RawAddr structure is only
   // used for datagram sockets.
-  static intptr_t SendTo(
-      intptr_t fd, const void* buffer, intptr_t num_bytes, const RawAddr& addr);
-  static intptr_t RecvFrom(
-      intptr_t fd, void* buffer, intptr_t num_bytes, RawAddr* addr);
+  static intptr_t SendTo(intptr_t fd,
+                         const void* buffer,
+                         intptr_t num_bytes,
+                         const RawAddr& addr);
+  static intptr_t RecvFrom(intptr_t fd,
+                           void* buffer,
+                           intptr_t num_bytes,
+                           RawAddr* addr);
   // Creates a socket which is bound and connected. The port to connect to is
   // specified as the port component of the passed RawAddr structure.
   static intptr_t CreateConnect(const RawAddr& addr);
   // Creates a socket which is bound and connected. The port to connect to is
   // specified as the port component of the passed RawAddr structure.
   static intptr_t CreateBindConnect(const RawAddr& addr,
                                     const RawAddr& source_addr);
   // Returns true if the given error-number is because the system was not able
   // to bind the socket to a specific IP.
   static bool IsBindError(intptr_t error_number);
@@ skipping 82 matching lines @@
   static bool StartAccept(intptr_t fd);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServerSocket);
 };
 
 
 class ListeningSocketRegistry {
  public:
-  ListeningSocketRegistry() :
-      sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
-      sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
-      mutex_(new Mutex()) {}
+  ListeningSocketRegistry()
+      : sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
+        sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
+        mutex_(new Mutex()) {}
 
   ~ListeningSocketRegistry() {
     CloseAllSafe();
     delete mutex_;
     mutex_ = NULL;
   }
 
   static void Initialize();
 
-  static ListeningSocketRegistry *Instance();
+  static ListeningSocketRegistry* Instance();
 
   static void Cleanup();
 
   // This function should be called from a dart runtime call in order to create
   // a new (potentially shared) socket.
   Dart_Handle CreateBindListen(Dart_Handle socket_object,
                                RawAddr addr,
                                intptr_t backlog,
                                bool v6_only,
                                bool shared);
 
   // This should be called from the event handler for every kCloseEvent it gets
   // on listening sockets.
   //
   // Returns `true` if the last reference has been dropped and the underlying
   // socket can be closed.
   //
   // The caller is responsible for obtaining the mutex first, before calling
   // this function.
   bool CloseSafe(intptr_t socketfd);
 
-  Mutex *mutex() { return mutex_; }
+  Mutex* mutex() { return mutex_; }
 
  private:
   struct OSSocket {
     RawAddr address;
     int port;
     bool v6_only;
     bool shared;
     int ref_count;
     intptr_t socketfd;
 
     // Singly linked lists of OSSocket instances which listen on the same port
     // but on different addresses.
-    OSSocket *next;
+    OSSocket* next;
 
-    OSSocket(RawAddr address, int port, bool v6_only, bool shared,
+    OSSocket(RawAddr address,
+             int port,
+             bool v6_only,
+             bool shared,
              intptr_t socketfd)
-        : address(address), port(port), v6_only(v6_only), shared(shared),
-          ref_count(0), socketfd(socketfd), next(NULL) {}
+        : address(address),
+          port(port),
+          v6_only(v6_only),
+          shared(shared),
+          ref_count(0),
+          socketfd(socketfd),
+          next(NULL) {}
   };
 
   static const intptr_t kInitialSocketsCount = 8;
 
-  OSSocket *findOSSocketWithAddress(OSSocket *current, const RawAddr& addr) {
+  OSSocket* findOSSocketWithAddress(OSSocket* current, const RawAddr& addr) {
     while (current != NULL) {
       if (SocketAddress::AreAddressesEqual(current->address, addr)) {
         return current;
       }
       current = current->next;
     }
     return NULL;
   }
 
   static bool SameIntptrValue(void* key1, void* key2) {
@@ skipping 16 matching lines @@
   OSSocket* LookupByFd(intptr_t fd);
   void InsertByFd(intptr_t fd, OSSocket* socket);
   void RemoveByFd(intptr_t fd);
 
   bool CloseOneSafe(OSSocket* os_socket);
   void CloseAllSafe();
 
   HashMap sockets_by_port_;
   HashMap sockets_by_fd_;
 
-  Mutex *mutex_;
+  Mutex* mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_SOCKET_H_