Replace std::map with base::SmallMap in ui::LatencyInfo

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 <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/containers/small_map.h"
 #include "base/files/file.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/tuple.h"
 #include "ipc/ipc_message_start.h"
 #include "ipc/ipc_param_traits.h"
 #include "ipc/ipc_sync_message.h"
@@ skipping 639 matching lines @@
   }
   static void Log(const param_type& p, std::string* l) {
     for (size_t i = 0; i < p.size(); ++i) {
       if (i != 0)
         l->append(" ");
       LogParam(*p[i], l);
     }
   }
 };
 
+template <typename NormalMap,
+          int kArraySize,
+          typename EqualKey,
+          typename MapInit>
+struct ParamTraits<base::SmallMap<NormalMap, kArraySize, EqualKey, MapInit> > {
+  typedef base::SmallMap<NormalMap, kArraySize, EqualKey, MapInit> param_type;
+  typedef typename param_type::key_type K;
+  typedef typename param_type::data_type V;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.size()));

[Tom Sepez, 2014/02/14 19:05:37]

we ought to be careful here if p.size() > INT_MAX, if such a thing is possible
in the underlying type, because later we are using the iterator, not the size to
bound the loop. I'm not sure whether we can make this happen in practice.

[Tom Sepez, 2014/02/14 19:14:42]

Though std::map has this same issue, so this is probably OK for now, but I need
to think about both of these.

[jdduke (slow), 2014/02/18 01:42:21]

Good point.  I think some other container types may experience this as well
(std::vector, std::set, ScopedVector).  I'm not quite sure what the best
solution is here, so I'll defer to your judgement.

+    typename param_type::const_iterator iter;
+    for (iter = p.begin(); iter != p.end(); ++iter) {
+      WriteParam(m, iter->first);
+      WriteParam(m, iter->second);
+    }
+  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
+    int size;
+    if (!m->ReadLength(iter, &size))
+      return false;
+    for (int i = 0; i < size; ++i) {

[Tom Sepez, 2014/02/14 19:05:37]

This one is more important: You'll want to return false here if size < 0, to be
safe if a compromised renderer should send a bad message.

[jdduke (slow), 2014/02/18 01:42:21]

Hmm, I was under the impression that |ReadLength()| performs that check already?

+      K key;
+      if (!ReadParam(m, iter, &key))
+        return false;
+      V& value = (*r)[k];
+      if (!ReadParam(m, iter, &value))
+        return false;
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<base::SmallMap>");
+  }
+};
+
 // IPC types ParamTraits -------------------------------------------------------
 
 // A ChannelHandle is basically a platform-inspecific wrapper around the
 // fact that IPC endpoints are handled specially on POSIX.  See above comments
 // on FileDescriptor for more background.
 template<>
 struct IPC_EXPORT ParamTraits<IPC::ChannelHandle> {
   typedef ChannelHandle param_type;
   static void Write(Message* m, const param_type& p);
   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
@@ skipping 195 matching lines @@
   template<typename TA, typename TB, typename TC, typename TD, typename TE>
   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e) {
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_