mojo: Switch the clipboard interface over to using map<>.

mojo/public/cpp/bindings/lib/map_internal.h

 // Copyright 2014 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 MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_
 
 #include <map>
 
 #include "mojo/public/cpp/bindings/array.h"
@@ skipping 53 matching lines @@
   }
   static inline ValueConstRefType at(
       const std::map<KeyStorageType, ValueStorageType>* m,
       KeyForwardType key) {
     // We don't have C++11 library support yet, so we have to emulate the crash
     // on a non-existant key.
     auto it = m->find(key);
     MOJO_CHECK(it != m->end());
     return it->second;
   }
+  static inline ValueRefType Index(

[viettrungluu, 2014/10/15 23:17:23]

Hmmm. I still find the name "Index" a bit perplexing.

Maybe it should be "GetOrInsert" / "AtOrInsert" / ...? (Or maybe there should be
an explanatory comment?)

(An alternative might be to try to make "Insert" return a ValueRefType, etc. but
it's a bit awkward with the whole move-only business. Hrm.)

[Elliot Glaysher, 2014/10/15 23:30:44]

Because it is the backing for the index operator. Still, changed the name to
"GetOrInsert" and added a comment.

+      std::map<KeyStorageType, ValueStorageType>* m,
+      KeyForwardType key) {
+    return (*m)[key];
+  }
   static inline void Insert(std::map<KeyStorageType, ValueStorageType>* m,
                             KeyForwardType key,
                             ValueForwardType value) {
     m->insert(std::make_pair(key, value));
   }
   static inline KeyConstRefType GetKey(
       const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
           it) {
     return it->first;
   }
@@ skipping 64 matching lines @@
     // We don't have C++11 library support yet, so we have to emulate the crash
     // on a non-existant key.
     auto it = m->find(key);
     MOJO_CHECK(it != m->end());
     return GetValue(it);
   }
   static inline ValueConstRefType at(
       const std::map<KeyStorageType, ValueStorageType>* m,
       KeyForwardType key) {
     // We don't have C++11 library support yet, so we have to emulate the crash
     // on a non-existant key.

[viettrungluu, 2014/10/15 23:17:23]

drive-by retroactive correction: "existant" -> "existent"

     auto it = m->find(key);
     MOJO_CHECK(it != m->end());
     return GetValue(it);
   }
+  static inline ValueRefType Index(
+      std::map<KeyStorageType, ValueStorageType>* m,
+      KeyForwardType key) {
+    auto it = m->find(key);
+    if (it == m->end()) {
+      it = m->insert(std::make_pair(key, ValueStorageType())).first;
+      new (it->second.buf) Value();
+    }
+
+    return GetValue(it);
+  }
   static inline void Insert(std::map<KeyStorageType, ValueStorageType>* m,
                             KeyForwardType key,
                             ValueRefType value) {
     // STL insert() doesn't insert |value| if |key| is already part of |m|. We
     // have to use operator[] to initialize into the storage buffer, but we
     // have to do a manual check so that we don't overwrite an existing object.
     auto it = m->find(key);
     if (it == m->end())
       new ((*m)[key].buf) Value(value.Pass());
   }
@@ skipping 18 matching lines @@
     dst->clear();
     for (auto it = src.begin(); it != src.end(); ++it)
       new ((*dst)[it->first].buf) Value(GetValue(it).Clone());
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_