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{0};
  39   int64_t expiration{0};
  40   bool TRR{false};
  41   nsCString originAttributesSuffix;
  42   nsCString flags;
  43   uint16_t resolveType{0};
  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.TRR);
 103     WriteParam(aWriter, aParam.originAttributesSuffix);
 104     WriteParam(aWriter, aParam.flags);
 105     WriteParam(aWriter, aParam.resolveType);
 106   }
 107
 108   static bool Read(MessageReader* aReader, paramType* aResult) {
 109     return ReadParam(aReader, &aResult->hostname) &&
 110            ReadParam(aReader, &aResult->hostaddr) &&
 111            ReadParam(aReader, &aResult->family) &&
 112            ReadParam(aReader, &aResult->expiration) &&
 113            ReadParam(aReader, &aResult->TRR) &&
 114            ReadParam(aReader, &aResult->originAttributesSuffix) &&
 115            ReadParam(aReader, &aResult->flags) &&
 116            ReadParam(aReader, &aResult->resolveType);
 117   }
 118 };
 119
 120 template <>
 121 struct ParamTraits<mozilla::net::DnsAndConnectSockets> {
 122   typedef mozilla::net::DnsAndConnectSockets paramType;
 123
 124   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 125     WriteParam(aWriter, aParam.speculative);
 126   }
 127
 128   static bool Read(MessageReader* aReader, paramType* aResult) {
 129     return ReadParam(aReader, &aResult->speculative);
 130   }
 131 };
 132
 133 template <>
 134 struct ParamTraits<mozilla::net::HttpConnInfo> {
 135   typedef mozilla::net::HttpConnInfo paramType;
 136
 137   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 138     WriteParam(aWriter, aParam.ttl);
 139     WriteParam(aWriter, aParam.rtt);
 140     WriteParam(aWriter, aParam.protocolVersion);
 141   }
 142
 143   static bool Read(MessageReader* aReader, paramType* aResult) {
 144     return ReadParam(aReader, &aResult->ttl) &&
 145            ReadParam(aReader, &aResult->rtt) &&
 146            ReadParam(aReader, &aResult->protocolVersion);
 147   }
 148 };
 149
 150 template <>
 151 struct ParamTraits<mozilla::net::HttpRetParams> {
 152   typedef mozilla::net::HttpRetParams paramType;
 153
 154   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 155     WriteParam(aWriter, aParam.host);
 156     WriteParam(aWriter, aParam.active);
 157     WriteParam(aWriter, aParam.idle);
 158     WriteParam(aWriter, aParam.dnsAndSocks);
 159     WriteParam(aWriter, aParam.counter);
 160     WriteParam(aWriter, aParam.port);
 161     WriteParam(aWriter, aParam.httpVersion);
 162     WriteParam(aWriter, aParam.ssl);
 163   }
 164
 165   static bool Read(MessageReader* aReader, paramType* aResult) {
 166     return ReadParam(aReader, &aResult->host) &&
 167            ReadParam(aReader, &aResult->active) &&
 168            ReadParam(aReader, &aResult->idle) &&
 169            ReadParam(aReader, &aResult->dnsAndSocks) &&
 170            ReadParam(aReader, &aResult->counter) &&
 171            ReadParam(aReader, &aResult->port) &&
 172            ReadParam(aReader, &aResult->httpVersion) &&
 173            ReadParam(aReader, &aResult->ssl);
 174   }
 175 };
 176
 177 }  // namespace IPC
 178
 179 #endif  // mozilla_net_DashboardTypes_h_