Mojo C++ bindings: more consistent Clone() and Equals().

mojo/public/cpp/bindings/map.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_MAP_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
 
 #include <stddef.h>
 #include <map>
 #include <utility>
 
 #include "base/logging.h"
-#include "mojo/public/cpp/bindings/lib/map_internal.h"
-#include "mojo/public/cpp/bindings/lib/value_traits.h"
+#include "base/move.h"
+#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
+#include "mojo/public/cpp/bindings/lib/template_util.h"
+#include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 
 // A move-only map that can handle move-only values. Map has the following
 // characteristics:
 //   - The map itself can be null, and this is distinct from empty.
 //   - Keys must not be move-only.
 //   - The Key-type's "<" operator is used to sort the entries, and also is
 //     used to determine equality of the key values.
 //   - There can only be one entry per unique key.
@@ skipping 152 matching lines @@
       value_vector.push_back(std::move(entry.second));
     }
 
     map_.clear();
     is_null_ = true;
 
     keys->Swap(&key_vector);
     values->Swap(&value_vector);
   }
 
-  // Returns a new Map that contains a copy of the contents of this map.  If the
-  // values are of a type that is designated move-only, they will be cloned
-  // using the Clone() method of the type. Please note that calling this method
-  // will fail compilation if the value type cannot be cloned (which usually
-  // means that it is a Mojo handle type or a type that contains Mojo handles).
+  // Returns a new Map that contains a copy of the contents of this map. If the
+  // key/value type defines a Clone() method, it will be used; otherwise copy
+  // constructor/assignment will be used.
+  //
+  // Please note that calling this method will fail compilation if the key/value
+  // type cannot be cloned (which usually means that it is a Mojo handle type or
+  // a type containing Mojo handles).
   Map Clone() const {
     Map result;
     result.is_null_ = is_null_;
-    Traits::Clone(map_, &result.map_);
+    for (auto it = map_.begin(); it != map_.end(); ++it) {
+      result.map_.insert(std::make_pair(internal::Clone(it->first),
+                                        internal::Clone(it->second)));
+    }
     return result;
   }
 
   // Indicates whether the contents of this map are equal to those of another
-  // Map (including nullness). Keys are compared by the != operator. Values are
-  // compared as follows:
-  //   - Map, Array, Struct, or StructPtr values are compared by their Equals()
-  //     method.
-  //   - ScopedHandleBase-derived types are compared by their handles.
-  //   - Values of other types are compared by their "==" operator.
+  // Map (including nullness). If the key/value type defines an Equals() method,
+  // it will be used; otherwise == operator will be used.
   bool Equals(const Map& other) const {
     if (is_null() != other.is_null())
       return false;
     if (size() != other.size())
       return false;
     auto i = begin();
     auto j = other.begin();
     while (i != end()) {
-      if (i->first != j->first)
+      if (!internal::Equals(i->first, j->first))
         return false;
-      if (!internal::ValueTraits<Value>::Equals(i->second, j->second))
+      if (!internal::Equals(i->second, j->second))
         return false;
       ++i;
       ++j;
     }
     return true;
   }
 
   // Provide read-only iteration over map members in a way similar to STL
   // collections.
   ConstIterator begin() const { return map_.begin(); }
@@ skipping 10 matching lines @@
  private:
   typedef std::map<Key, Value> Map::*Testable;
 
  public:
   // The Map may be used in boolean expressions to determine if it is non-null,
   // but is not implicitly convertible to an actual bool value (which would be
   // dangerous).
   operator Testable() const { return is_null_ ? 0 : &Map::map_; }
 
  private:
-  using Traits =
-      internal::MapCloneTraits<Key,
-                               Value,
-                               internal::IsMoveOnlyType<Value>::value>;
-
   // Forbid the == and != operators explicitly, otherwise Map will be converted
   // to Testable to do == or != comparison.
   template <typename T, typename U>
   bool operator==(const Map<T, U>& other) const = delete;
   template <typename T, typename U>
   bool operator!=(const Map<T, U>& other) const = delete;
 
   void Take(Map* other) {
     operator=(nullptr);
     Swap(other);
@@ skipping 38 matching lines @@
             TypeConverter<STLValue, MojoValue>::Convert(it->second)));
       }
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_