netwerk/base/DashboardTypes.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef mozilla_net_DashboardTypes_h_
   6 #define mozilla_net_DashboardTypes_h_
   7
   8 #include "ipc/IPCMessageUtils.h"
   9 #include "ipc/IPCMessageUtilsSpecializations.h"
  10 #include "nsHttp.h"
  11 #include "nsString.h"
  12 #include "nsTArray.h"
  13
  14 namespace mozilla {
  15 namespace net {
  16
  17 struct SocketInfo {
  18   nsCString host;
  19   uint64_t sent;
  20   uint64_t received;
  21   uint16_t port;
  22   bool active;
  23   nsCString type;
  24 };
  25
  26 inline bool operator==(const SocketInfo& a, const SocketInfo& b) {
  27   return a.host == b.host && a.sent == b.sent && a.received == b.received &&
  28          a.port == b.port && a.active == b.active && a.type == b.type;
  29 }
  30
  31 struct DnsAndConnectSockets {
  32   bool speculative;
  33 };
  34
  35 struct DNSCacheEntries {
  36   nsCString hostname;
  37   nsTArray<nsCString> hostaddr;
  38   uint16_t family;
  39   int64_t expiration;
  40   nsCString netInterface;
  41   bool TRR;
  42   nsCString originAttributesSuffix;
  43   nsCString flags;
  44 };
  45
  46 struct HttpConnInfo {
  47   uint32_t ttl;
  48   uint32_t rtt;
  49   nsString protocolVersion;
  50
  51   void SetHTTPProtocolVersion(HttpVersion pv);
  52 };
  53
  54 struct HttpRetParams {
  55   nsCString host;
  56   CopyableTArray<HttpConnInfo> active;
  57   CopyableTArray<HttpConnInfo> idle;
  58   CopyableTArray<DnsAndConnectSockets> dnsAndSocks;
  59   uint32_t counter;
  60   uint16_t port;
  61   nsCString httpVersion;
  62   bool ssl;
  63 };
  64
  65 }  // namespace net
  66 }  // namespace mozilla
  67
  68 namespace IPC {
  69
  70 template <>
  71 struct ParamTraits<mozilla::net::SocketInfo> {
  72   typedef mozilla::net::SocketInfo paramType;
  73
  74   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  75     WriteParam(aWriter, aParam.host);
  76     WriteParam(aWriter, aParam.sent);
  77     WriteParam(aWriter, aParam.received);
  78     WriteParam(aWriter, aParam.port);
  79     WriteParam(aWriter, aParam.active);
  80     WriteParam(aWriter, aParam.type);
  81   }
  82
  83   static bool Read(MessageReader* aReader, paramType* aResult) {
  84     return ReadParam(aReader, &aResult->host) &&
  85            ReadParam(aReader, &aResult->sent) &&
  86            ReadParam(aReader, &aResult->received) &&
  87            ReadParam(aReader, &aResult->port) &&
  88            ReadParam(aReader, &aResult->active) &&
  89            ReadParam(aReader, &aResult->type);
  90   }
  91 };
  92
  93 template <>
  94 struct ParamTraits<mozilla::net::DNSCacheEntries> {
  95   typedef mozilla::net::DNSCacheEntries paramType;
  96
  97   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  98     WriteParam(aWriter, aParam.hostname);
  99     WriteParam(aWriter, aParam.hostaddr);
 100     WriteParam(aWriter, aParam.family);
 101     WriteParam(aWriter, aParam.expiration);
 102     WriteParam(aWriter, aParam.netInterface);
 103     WriteParam(aWriter, aParam.TRR);
 104   }
 105
 106   static bool Read(MessageReader* aReader, paramType* aResult) {
 107     return ReadParam(aReader, &aResult->hostname) &&
 108            ReadParam(aReader, &aResult->hostaddr) &&
 109            ReadParam(aReader, &aResult->family) &&
 110            ReadParam(aReader, &aResult->expiration) &&
 111            ReadParam(aReader, &aResult->netInterface) &&
 112            ReadParam(aReader, &aResult->TRR);
 113   }
 114 };
 115
 116 template <>
 117 struct ParamTraits<mozilla::net::DnsAndConnectSockets> {
 118   typedef mozilla::net::DnsAndConnectSockets paramType;
 119
 120   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 121     WriteParam(aWriter, aParam.speculative);
 122   }
 123
 124   static bool Read(MessageReader* aReader, paramType* aResult) {
 125     return ReadParam(aReader, &aResult->speculative);
 126   }
 127 };
 128
 129 template <>
 130 struct ParamTraits<mozilla::net::HttpConnInfo> {
 131   typedef mozilla::net::HttpConnInfo paramType;
 132
 133   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 134     WriteParam(aWriter, aParam.ttl);
 135     WriteParam(aWriter, aParam.rtt);
 136     WriteParam(aWriter, aParam.protocolVersion);
 137   }
 138
 139   static bool Read(MessageReader* aReader, paramType* aResult) {
 140     return ReadParam(aReader, &aResult->ttl) &&
 141            ReadParam(aReader, &aResult->rtt) &&
 142            ReadParam(aReader, &aResult->protocolVersion);
 143   }
 144 };
 145
 146 template <>
 147 struct ParamTraits<mozilla::net::HttpRetParams> {
 148   typedef mozilla::net::HttpRetParams paramType;
 149
 150   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 151     WriteParam(aWriter, aParam.host);
 152     WriteParam(aWriter, aParam.active);
 153     WriteParam(aWriter, aParam.idle);
 154     WriteParam(aWriter, aParam.dnsAndSocks);
 155     WriteParam(aWriter, aParam.counter);
 156     WriteParam(aWriter, aParam.port);
 157     WriteParam(aWriter, aParam.httpVersion);
 158     WriteParam(aWriter, aParam.ssl);
 159   }
 160
 161   static bool Read(MessageReader* aReader, paramType* aResult) {
 162     return ReadParam(aReader, &aResult->host) &&
 163            ReadParam(aReader, &aResult->active) &&
 164            ReadParam(aReader, &aResult->idle) &&
 165            ReadParam(aReader, &aResult->dnsAndSocks) &&
 166            ReadParam(aReader, &aResult->counter) &&
 167            ReadParam(aReader, &aResult->port) &&
 168            ReadParam(aReader, &aResult->httpVersion) &&
 169            ReadParam(aReader, &aResult->ssl);
 170   }
 171 };
 172
 173 }  // namespace IPC
 174
 175 #endif  // mozilla_net_DashboardTypes_h_