Migrate remoting to net::IPAddress.

remoting/host/chromoting_param_traits.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/host/chromoting_param_traits.h"
 
 #include <stdint.h>
 
 #include "base/strings/stringprintf.h"
+#include "ipc/ipc_message_utils.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace IPC {
 
 // static
 void ParamTraits<webrtc::DesktopVector>::Write(base::Pickle* m,
                                                const webrtc::DesktopVector& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
@@ skipping 161 matching lines @@
 
 // static
 void ParamTraits<remoting::ScreenResolution>::Log(
     const remoting::ScreenResolution& p,
     std::string* l) {
   l->append(base::StringPrintf("webrtc::ScreenResolution(%d, %d, %d, %d)",
                                p.dimensions().width(), p.dimensions().height(),
                                p.dpi().x(), p.dpi().y()));
 }
 
+// static
+void ParamTraits<net::IPAddress>::Write(base::Pickle* m, const param_type& p) {
+  WriteParam(m, p.bytes());
+}
+
+// static
+bool ParamTraits<net::IPAddress>::Read(const base::Pickle* m,
+                                       base::PickleIterator* iter,
+                                       param_type* p) {
+  std::vector<uint8_t> bytes;
+  if (!ReadParam(m, iter, &bytes))
+    return false;
+  if (bytes.size() && bytes.size() != net::IPAddress::kIPv4AddressSize &&
+      bytes.size() != net::IPAddress::kIPv6AddressSize) {

[Wez, 2016/04/05 17:08:01]

This would be more readable as:

if (bytes.empty()) {
  *p = net::IPAddress();
  return true;
}
if ((bytes.size() != ...) &&
    (bytes.size() != ...) {
  return false;
}

[martijnc, 2016/04/05 20:08:48]

Done.

+    return false;
+  }
+  *p = net::IPAddress(bytes);
+  return true;
+}
+
+// static
+void ParamTraits<net::IPAddress>::Log(const param_type& p, std::string* l) {
+  l->append("IPAddress:" + (p.empty() ? "(empty)" : p.ToString()));
+}
+
+// static
+void ParamTraits<net::IPEndPoint>::Write(base::Pickle* m, const param_type& p) {
+  WriteParam(m, p.address());
+  WriteParam(m, p.port());
+}
+
+// static
+bool ParamTraits<net::IPEndPoint>::Read(const base::Pickle* m,
+                                        base::PickleIterator* iter,
+                                        param_type* p) {
+  net::IPAddress address;
+  uint16_t port;
+  if (!ReadParam(m, iter, &address) || !ReadParam(m, iter, &port))
+    return false;
+  if (!address.empty() && !address.IsValid())

[Wez, 2016/04/05 17:08:01]

Similarly, this is painful to parse; better to have if (address.empty()) set an
empty endpoint and early-exit?

[martijnc, 2016/04/05 20:08:48]

Done.

(the IPAddress should always be valid (or empty) here because the IPAddress
ParamTraits does the same check.)

[Wez, 2016/04/05 20:12:27]

The IPAddress ParamTraits doesn't seem to do an IsValid check, AFAICT - that
would probably make sense as the return-code. It may be that the IsValid() check
always returns true because the size of the IPAddress is all that it checks, but
if some checks are added later, it would be good to have them applied in Read()
for IPAddress.

Since IPAddress already checks these, don't check them here as well.

[martijnc, 2016/04/05 21:16:29]

Done.

+    return false;
+
+  *p = net::IPEndPoint(address, port);
+  return true;
+}
+
+// static
+void ParamTraits<net::IPEndPoint>::Log(const param_type& p, std::string* l) {
+  l->append("IPEndPoint: " + p.ToString());
+}
+
 }  // namespace IPC