Support Serializing and Deserializing RepeatedField / RepeatedPtrField in IPC::Message

ipc/ipc_message_repeated_field_utils.h

+// Copyright 2017 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.
+
+#ifndef IPC_IPC_MESSAGE_REPEATED_FIELD_UTILS_H_
+#define IPC_IPC_MESSAGE_REPEATED_FIELD_UTILS_H_
+
+#include "build/build_config.h"
+
+#if defined(OS_NACL_NONSFI)
+static_assert(false,
+              "ipc_message_repeated_field_utils is not able to work with "
+              "nacl_nonsfi configuration.");
+#endif
+
+#include "base/pickle.h"
+#include "ipc/ipc_param_traits.h"
+#include "ipc/ipc_message_utils.h"
+#include "third_party/protobuf/src/google/protobuf/repeated_field.h"
+
+namespace IPC {
+
+template <template<class> class RepeatedFieldLike, class P>

[dcheng, 2017/07/10 18:38:10]

Is it important to include the template<class> here? I'm wondering if it would
be simpler to just omit it.

[Hzj_jie, 2017/07/10 23:53:37]

These two comments are conflict :)
If we prefer to check the bounds and reserve beforehand, template parameter P is
required.

[dcheng, 2017/07/11 05:38:59]

Hmm. I guess I don't really care if we Reserve(). However, I feel like we might
need the bounds check either way: it looks to me like
https://cs.chromium.org/chromium/src/third_party/protobuf/src/google/protobuf...
doesn't check for overflow, and could easily hit problems.

And if we have to do that, we may as well Reserve().

(And yes, if we need the template parameter, we need it. But in that case, it
would be named and used, so it's no longer unused)

[Hzj_jie, 2017/07/11 05:59:02]

Why cannot we use base::Pickle::payload_size() to check the boundary? I followed
the example in std::vector<P>, but really do not understand the condition at
(https://cs.chromium.org/chromium/src/ipc/ipc_message_utils.h?rcl=d9917f026d85...).

+struct RepeatedFieldParamTraits {
+  typedef RepeatedFieldLike<P> param_type;
+  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
+    GetParamSize(sizer, p.size());
+    for (int i = 0; i < p.size(); i++)
+      GetParamSize(sizer, p.Get(i));
+  }
+  static void Write(base::Pickle* m, const param_type& p) {
+    WriteParam(m, p.size());
+    for (int i = 0; i < p.size(); i++)
+      WriteParam(m, p.Get(i));
+  }
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r) {
+    int size;
+    // ReadLength() checks for < 0 itself.
+    if (!iter->ReadLength(&size))
+      return false;
+    for (int i = 0; i < size; i++) {

[dcheng, 2017/07/10 18:38:10]

Nit: let's keep the original logic to do bounds checking and the reservation?

[Hzj_jie, 2017/07/10 23:53:37]

Done.

+      if (!ReadParam(m, iter, r->Add()))
+        return false;
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    for (int i = 0; i < p.size(); ++i) {
+      if (i != 0)
+        l->append(" ");
+      LogParam(p.Get(i), l);
+    }
+  }
+};
+
+template <class P>
+struct ParamTraits<google::protobuf::RepeatedField<P>> :
+    RepeatedFieldParamTraits<google::protobuf::RepeatedField, P> {};
+
+template <class P>
+struct ParamTraits<google::protobuf::RepeatedPtrField<P>> :
+    RepeatedFieldParamTraits<google::protobuf::RepeatedPtrField, P> {};
+
+}  // namespace IPC
+
+#endif  // IPC_IPC_MESSAGE_REPEATED_FIELD_UTILS_H_