Mojo C++ bindings: make mojo::Map<K,V> more friendly with std::map<K,V>.

mojo/public/cpp/bindings/tests/map_unittest.cc

 // 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.
 
 #include "mojo/public/cpp/bindings/map.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 74 matching lines @@
     Array<int32_t> array(1);
     array[0] = kStringIntData[i].int_data;
     map[key] = std::move(array);
     EXPECT_TRUE(map);
   }
 
   // We now read back that data, to test the behavior of operator[].
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     auto it = map.find(kStringIntData[i].string_data);
     ASSERT_TRUE(it != map.end());
-    ASSERT_EQ(1u, it.GetValue().size());
-    EXPECT_EQ(kStringIntData[i].int_data, it.GetValue()[0]);
+    ASSERT_EQ(1u, it->second.size());
+    EXPECT_EQ(kStringIntData[i].int_data, it->second[0]);
   }
 }
 
 TEST_F(MapTest, ConstructedFromArray) {
   Array<String> keys(kStringIntDataSize);
   Array<int> values(kStringIntDataSize);
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     keys[i] = kStringIntData[i].string_data;
     values[i] = kStringIntData[i].int_data;
   }
@@ skipping 152 matching lines @@
   Map<String, Array<String>> m;
   for (size_t i = 0; i < kStringIntDataSize; ++i) {
     Array<String> s;
     s.push_back(kStringIntData[i].string_data);
     m.insert(kStringIntData[i].string_data, std::move(s));
   }
 
   Map<String, Array<String>> m2 = m.Clone();
 
   for (auto it = m2.begin(); it != m2.end(); ++it) {
-    ASSERT_EQ(1u, it.GetValue().size());
-    EXPECT_EQ(it.GetKey(), it.GetValue().at(0));
+    ASSERT_EQ(1u, it->second.size());
+    EXPECT_EQ(it->first, it->second.at(0));
   }
 }
 
 TEST_F(MapTest, ArrayOfMap) {
   {
     Array<Map<int32_t, int8_t>> array(1);
     array[0].insert(1, 42);
 
     size_t size = GetSerializedSize_(array);
     FixedBufferForTesting buf(size);
@@ skipping 28 matching lines @@
     Array<Map<String, Array<bool>>> deserialized_array;
     Deserialize_(data, &deserialized_array, nullptr);
 
     ASSERT_EQ(1u, deserialized_array.size());
     ASSERT_EQ(1u, deserialized_array[0].size());
     ASSERT_FALSE(deserialized_array[0].at("hello world")[0]);
     ASSERT_TRUE(deserialized_array[0].at("hello world")[1]);
   }
 }
 
+TEST_F(MapTest, MoveFromAndToSTLMap_Copyable) {
+  std::map<int32_t, CopyableType> map1;
+  map1.insert(std::make_pair(123, CopyableType()));
+  map1[123].ResetCopied();
+
+  Map<int32_t, CopyableType> mojo_map(std::move(map1));
+  ASSERT_EQ(1u, mojo_map.size());
+  ASSERT_NE(mojo_map.end(), mojo_map.find(123));
+  ASSERT_FALSE(mojo_map[123].copied());
+
+  std::map<int32_t, CopyableType> map2(mojo_map.PassStorage());
+  ASSERT_EQ(1u, map2.size());
+  ASSERT_NE(map2.end(), map2.find(123));
+  ASSERT_FALSE(map2[123].copied());
+
+  ASSERT_EQ(0u, mojo_map.size());
+  ASSERT_TRUE(mojo_map.is_null());
+}
+
+TEST_F(MapTest, MoveFromAndToSTLMap_MoveOnly) {
+  std::map<int32_t, MoveOnlyType> map1;
+  map1.insert(std::make_pair(123, MoveOnlyType()));
+
+  Map<int32_t, MoveOnlyType> mojo_map(std::move(map1));
+  ASSERT_EQ(1u, mojo_map.size());
+  ASSERT_NE(mojo_map.end(), mojo_map.find(123));
+
+  std::map<int32_t, MoveOnlyType> map2(mojo_map.PassStorage());
+  ASSERT_EQ(1u, map2.size());
+  ASSERT_NE(map2.end(), map2.find(123));
+
+  ASSERT_EQ(0u, mojo_map.size());
+  ASSERT_TRUE(mojo_map.is_null());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace mojo