Clang plugin to check that unstable types are not used in IPC.

ipc/ipc_message_utils.h

 // Copyright (c) 2012 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_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 58 matching lines @@
   std::string params;
 };
 
 //-----------------------------------------------------------------------------
 
 // A dummy struct to place first just to allow leading commas for all
 // members in the macro-generated constructor initializer lists.
 struct NoParams {
 };
 
+// Specializations are checked by 'IPC checker' Clang plugin
+// (see WriteParam() below for the list of allowed types).
+template <typename... Ts>
+struct CheckedTuple {
+  typedef base::Tuple<Ts...> Tuple;
+};
+
 template <class P>
 static inline void GetParamSize(base::PickleSizer* sizer, const P& p) {
   typedef typename SimilarTypeTraits<P>::Type Type;
   ParamTraits<Type>::GetSize(sizer, static_cast<const Type&>(p));
 }
 
+// NOT checked by 'IPC checker' Clang plugin.

[jam, 2016/02/19 16:16:05]

perhaps add a presubmit check to ensure that WriteParamUnchecked isn't
accidentally used in more files?

+template <class P>
+static inline void WriteParamUnchecked(base::Pickle* m, const P& p) {
+  typedef typename SimilarTypeTraits<P>::Type Type;
+  ParamTraits<Type>::Write(m, static_cast<const Type& >(p));
+}
+
+// Checked by 'IPC checker' Clang plugin to enforce the following:
+// 1. int / unsigned int are allowed when used as is (not through typedef)
+// 2. long / unsigned long are banned
+// 3. Any typedefs to the types above are banned except for int32_t/uint32_t
+//    and int64_t/uint64_t (typedefs to these are allowed)
+// 4. All other types are allowed
 template <class P>
 static inline void WriteParam(base::Pickle* m, const P& p) {
-  typedef typename SimilarTypeTraits<P>::Type Type;
-  ParamTraits<Type>::Write(m, static_cast<const Type& >(p));
+  WriteParamUnchecked(m, p);
 }
 
 template <class P>
 static inline bool WARN_UNUSED_RESULT ReadParam(const base::Pickle* m,
                                                 base::PickleIterator* iter,
                                                 P* p) {
   typedef typename SimilarTypeTraits<P>::Type Type;
   return ParamTraits<Type>::Read(m, iter, reinterpret_cast<Type* >(p));
 }
 
@@ skipping 263 matching lines @@
 struct ParamTraits<std::vector<P> > {
   typedef std::vector<P> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, static_cast<int>(p.size()));
     for (size_t i = 0; i < p.size(); i++)
       GetParamSize(sizer, p[i]);
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     for (size_t i = 0; i < p.size(); i++)
-      WriteParam(m, p[i]);
+      WriteParam<P>(m, p[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;
     // Resizing beforehand is not safe, see BUG 1006367 for details.
     if (INT_MAX / sizeof(P) <= static_cast<size_t>(size))
@@ skipping 20 matching lines @@
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter)
       GetParamSize(sizer, *iter);
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter)
-      WriteParam(m, *iter);
+      WriteParam<P>(m, *iter);
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     int size;
     if (!iter->ReadLength(&size))
       return false;
     for (int i = 0; i < size; ++i) {
       P item;
       if (!ReadParam(m, iter, &item))
@@ skipping 15 matching lines @@
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter) {
       GetParamSize(sizer, iter->first);
       GetParamSize(sizer, iter->second);
     }
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter) {
-      WriteParam(m, iter->first);
-      WriteParam(m, iter->second);
+      WriteParam<K>(m, iter->first);
+      WriteParam<V>(m, iter->second);
     }
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     int size;
     if (!ReadParam(m, iter, &size) || size < 0)
       return false;
     for (int i = 0; i < size; ++i) {
       K k;
@@ skipping 11 matching lines @@
 };
 
 template <class A, class B>
 struct ParamTraits<std::pair<A, B> > {
   typedef std::pair<A, B> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, p.first);
     GetParamSize(sizer, p.second);
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, p.first);
-    WriteParam(m, p.second);
+    WriteParam<A>(m, p.first);
+    WriteParam<B>(m, p.second);
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("(");
     LogParam(p.first, l);
     l->append(", ");
@@ skipping 168 matching lines @@
   }
 };
 
 template <class A>
 struct ParamTraits<std::tuple<A>> {
   typedef std::tuple<A> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, base::get<0>(p));
+    WriteParam<A>(m, base::get<0>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return ReadParam(m, iter, &base::get<0>(*r));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
   }
 };
 
 template <class A, class B>
 struct ParamTraits<std::tuple<A, B>> {
   typedef std::tuple<A, B> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, base::get<0>(p));
-    WriteParam(m, base::get<1>(p));
+    WriteParam<A>(m, base::get<0>(p));
+    WriteParam<B>(m, base::get<1>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
     l->append(", ");
     LogParam(base::get<1>(p), l);
   }
 };
 
 template <class A, class B, class C>
 struct ParamTraits<std::tuple<A, B, C>> {
   typedef std::tuple<A, B, C> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
     GetParamSize(sizer, base::get<2>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, base::get<0>(p));
-    WriteParam(m, base::get<1>(p));
-    WriteParam(m, base::get<2>(p));
+    WriteParam<A>(m, base::get<0>(p));
+    WriteParam<B>(m, base::get<1>(p));
+    WriteParam<C>(m, base::get<2>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)) &&
             ReadParam(m, iter, &base::get<2>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
     l->append(", ");
     LogParam(base::get<1>(p), l);
     l->append(", ");
     LogParam(base::get<2>(p), l);
   }
 };
 
 template <class A, class B, class C, class D>
 struct ParamTraits<std::tuple<A, B, C, D>> {
   typedef std::tuple<A, B, C, D> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
     GetParamSize(sizer, base::get<2>(p));
     GetParamSize(sizer, base::get<3>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, base::get<0>(p));
-    WriteParam(m, base::get<1>(p));
-    WriteParam(m, base::get<2>(p));
-    WriteParam(m, base::get<3>(p));
+    WriteParam<A>(m, base::get<0>(p));
+    WriteParam<B>(m, base::get<1>(p));
+    WriteParam<C>(m, base::get<2>(p));
+    WriteParam<D>(m, base::get<3>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)) &&
             ReadParam(m, iter, &base::get<2>(*r)) &&
             ReadParam(m, iter, &base::get<3>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
@@ skipping 11 matching lines @@
 struct ParamTraits<std::tuple<A, B, C, D, E>> {
   typedef std::tuple<A, B, C, D, E> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, base::get<0>(p));
     GetParamSize(sizer, base::get<1>(p));
     GetParamSize(sizer, base::get<2>(p));
     GetParamSize(sizer, base::get<3>(p));
     GetParamSize(sizer, base::get<4>(p));
   }
   static void Write(base::Pickle* m, const param_type& p) {
-    WriteParam(m, base::get<0>(p));
-    WriteParam(m, base::get<1>(p));
-    WriteParam(m, base::get<2>(p));
-    WriteParam(m, base::get<3>(p));
-    WriteParam(m, base::get<4>(p));
+    WriteParam<A>(m, base::get<0>(p));
+    WriteParam<B>(m, base::get<1>(p));
+    WriteParam<C>(m, base::get<2>(p));
+    WriteParam<D>(m, base::get<3>(p));
+    WriteParam<E>(m, base::get<4>(p));
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     return (ReadParam(m, iter, &base::get<0>(*r)) &&
             ReadParam(m, iter, &base::get<1>(*r)) &&
             ReadParam(m, iter, &base::get<2>(*r)) &&
             ReadParam(m, iter, &base::get<3>(*r)) &&
             ReadParam(m, iter, &base::get<4>(*r)));
   }
   static void Log(const param_type& p, std::string* l) {
     LogParam(base::get<0>(p), l);
     l->append(", ");
     LogParam(base::get<1>(p), l);
     l->append(", ");
     LogParam(base::get<2>(p), l);
     l->append(", ");
     LogParam(base::get<3>(p), l);
     l->append(", ");
     LogParam(base::get<4>(p), l);
   }
 };
 
 template<class P>
 struct ParamTraits<ScopedVector<P> > {
   typedef ScopedVector<P> param_type;
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     for (size_t i = 0; i < p.size(); i++)
-      WriteParam(m, *p[i]);
+      WriteParam<P>(m, *p[i]);
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     int size = 0;
     if (!iter->ReadLength(&size))
       return false;
     if (INT_MAX/sizeof(P) <= static_cast<size_t>(size))
       return false;
     r->resize(size);
@@ skipping 17 matching lines @@
 struct ParamTraits<base::StackVector<P, stack_capacity> > {
   typedef base::StackVector<P, stack_capacity> param_type;
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     GetParamSize(sizer, static_cast<int>(p->size()));
     for (size_t i = 0; i < p->size(); i++)
       GetParamSize(sizer, p[i]);
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p->size()));
     for (size_t i = 0; i < p->size(); i++)
-      WriteParam(m, p[i]);
+      WriteParam<P>(m, p[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;
     // Sanity check for the vector size.
     if (INT_MAX / sizeof(P) <= static_cast<size_t>(size))
@@ skipping 28 matching lines @@
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter) {
       GetParamSize(sizer, iter->first);
       GetParamSize(sizer, iter->second);
     }
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
     typename param_type::const_iterator iter;
     for (iter = p.begin(); iter != p.end(); ++iter) {
-      WriteParam(m, iter->first);
-      WriteParam(m, iter->second);
+      // We expect that types for 'first' and 'second' are specified in
+      // the NormalMap instantiation and hence are checked by CheckedTuple.
+      // So it's safe to skip checks here.
+      WriteParamUnchecked(m, iter->first);
+      WriteParamUnchecked(m, iter->second);
     }
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     int size;
     if (!iter->ReadLength(&size))
       return false;
     for (int i = 0; i < size; ++i) {
       K key;
@@ skipping 16 matching lines @@
   static void GetSize(base::PickleSizer* sizer, const param_type& p) {
     bool valid = !!p;
     GetParamSize(sizer, valid);
     if (valid)
       GetParamSize(sizer, *p);
   }
   static void Write(base::Pickle* m, const param_type& p) {
     bool valid = !!p;
     WriteParam(m, valid);
     if (valid)
-      WriteParam(m, *p);
+      WriteParam<P>(m, *p);
   }
   static bool Read(const base::Pickle* m,
                    base::PickleIterator* iter,
                    param_type* r) {
     bool valid = false;
     if (!ReadParam(m, iter, &valid))
       return false;
 
     if (!valid) {
       r->reset();
@@ skipping 132 matching lines @@
 template <class ReplyParamType>
 inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
                                     const Message* msg) {}
 
 inline void ConnectMessageAndReply(const Message* msg, Message* reply) {}
 #endif
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_