Improvements to uses of base::SmallMap

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>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <tuple>
 #include <vector>
 
+#include "base/containers/flat_map.h"
 #include "base/containers/small_map.h"
 #include "base/containers/stack_container.h"
 #include "base/files/file.h"
 #include "base/format_macros.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "ipc/ipc_message_start.h"
 #include "ipc/ipc_param_traits.h"
 #include "ipc/ipc_sync_message.h"
 
 namespace base {
@@ skipping 858 matching lines @@
         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;
+struct ParamTraits<base::small_map<NormalMap, kArraySize, EqualKey, MapInit>> {
+  using param_type = base::small_map<NormalMap, kArraySize, EqualKey, MapInit>;
+  using K = typename param_type::key_type;
+  using V = typename param_type::data_type;
   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->first);
       GetParamSize(sizer, iter->second);
     }
   }
   static void Write(base::Pickle* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.size()));
@@ skipping 13 matching lines @@
       K key;
       if (!ReadParam(m, iter, &key))
         return false;
       V& value = (*r)[key];
       if (!ReadParam(m, iter, &value))
         return false;
     }
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
-    l->append("<base::SmallMap>");
+    l->append("<base::small_map>");
   }
 };
 
+template <class Key, class Mapped, class Compare>
+struct ParamTraits<base::flat_map<Key, Mapped, Compare>> {
+  using param_type = base::flat_map<Key, Mapped, Compare>;
+  static void GetSize(base::PickleSizer* sizer, const param_type& p) {
+    GetParamSize(sizer, base::checked_cast<int>(p.size()));
+    for (const auto& iter : p) {
+      GetParamSize(sizer, iter.first);
+      GetParamSize(sizer, iter.second);
+    }
+  }
+  static void Write(base::Pickle* m, const param_type& p) {
+    WriteParam(m, base::checked_cast<int>(p.size()));
+    typename param_type::const_iterator iter;

[estark, 2017/04/20 00:59:49]

unneeded?

+    for (const auto& iter : p) {
+      WriteParam(m, iter.first);
+      WriteParam(m, iter.second);
+    }
+  }
+  static bool Read(const base::Pickle* m,
+                   base::PickleIterator* iter,
+                   param_type* r) {
+    int size;
+    if (!iter->ReadLength(&size))
+      return false;
+
+    // Construct by creating in a vector and moving into the flat_map. Properly
+    // serialized flat_maps will be in-order so this will be O(n). Incorrectly
+    // serialized ones will still be handled properly.
+    std::vector<typename param_type::value_type> vect;
+    vect.resize(size);

[dcheng, 2017/04/20 01:30:47]

Hmm... too bad there's no great way to do this with reserve. Oh well!

[brettw, 2017/04/20 04:24:24]

I could certainly write reserve() and I did the first time I wrote this. It
would look like:

vect.reserve(size);
param_type::value_type pair;
for (...) {
  ReadParam(..., &pair.first);
  ReadParam(..., &pair.second);
  vect.push_back(std::move(pair));
}

This only does one default construction of the pair compared to default
constructing everything with the version I wrote. But it adds a move for
everything. I decided default constructions are usually cheaper than moves so
opted for the resize version.

+    for (int i = 0; i < size; ++i) {
+      if (!ReadParam(m, iter, &vect[i].first))
+        return false;
+      if (!ReadParam(m, iter, &vect[i].second))
+        return false;
+    }
+
+    *r = param_type(std::move(vect), base::KEEP_FIRST_OF_DUPES);
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<base::flat_map>");
+  }
+};
+
 template <class P>
 struct ParamTraits<std::unique_ptr<P>> {
   typedef std::unique_ptr<P> param_type;
   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) {
@@ skipping 183 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_