Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

base/id_map.h

 // Copyright (c) 2011 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 BASE_ID_MAP_H_
 #define BASE_ID_MAP_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
 #include <type_traits>
 #include <utility>
 
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 
-// Ownership semantics - own pointer means the pointer is deleted in Remove()
-// & during destruction
+// Ownership semantics:
+// - OwnPointer means we store a unique_ptr that owns the object (so the
+//   object is deleted in Remove() and during destruction).
+// - ExternalPointer means we store a raw pointer and don't own the object
+
+// TODO (http://crbug.com/647091): eliminate this enum, replace OwnPointer
+// mode in callsites with IDMap<unique_ptr<T>>
 enum IDMapOwnershipSemantics {
   IDMapExternalPointer,
   IDMapOwnPointer
 };
 
 // This object maintains a list of IDs that can be quickly converted to
 // pointers to objects. It is implemented as a hash table, optimized for
 // relatively small data sets (in the common case, there will be exactly one
 // item in the list).
 //
@@ skipping 29 matching lines @@
     // thread. However, all the accesses may take place on another thread (or
     // sequence), such as the IO thread. Detaching again to clean this up.
     sequence_checker_.DetachFromSequence();
   }
 
   // Sets whether Add and Replace should DCHECK if passed in NULL data.
   // Default is false.
   void set_check_on_null_data(bool value) { check_on_null_data_ = value; }
 
   // Adds a view with an automatically generated unique ID. See AddWithID.
-  // (This unique_ptr<> variant will not compile in IDMapExternalPointer mode.)
-  KeyType Add(std::unique_ptr<T> data) {
-    return AddInternal(std::move(data));
-  }
+  KeyType Add(V data) { return AddInternal(std::move(data)); }
 
   // Adds a new data member with the specified ID. The ID must not be in
   // the list. The caller either must generate all unique IDs itself and use
   // this function, or allow this object to generate IDs and call Add. These
   // two methods may not be mixed, or duplicate IDs may be generated.
-  // (This unique_ptr<> variant will not compile in IDMapExternalPointer mode.)
-  void AddWithID(std::unique_ptr<T> data, KeyType id) {
-    AddWithIDInternal(std::move(data), id);
-  }
-
-  // http://crbug.com/647091: Raw pointer Add()s in IDMapOwnPointer mode are
-  // deprecated.  Users of IDMapOwnPointer should transition to the unique_ptr
-  // variant above, and the following methods should only be used in
-  // IDMapExternalPointer mode.
-  KeyType Add(T* data) {
-    return AddInternal(V(data));
-  }
-  void AddWithID(T* data, KeyType id) {
-    AddWithIDInternal(V(data), id);
-  }
+  void AddWithID(V data, KeyType id) { AddWithIDInternal(std::move(data), id); }
 
   void Remove(KeyType id) {
     DCHECK(sequence_checker_.CalledOnValidSequence());
     typename HashTable::iterator i = data_.find(id);
     if (i == data_.end()) {
       NOTREACHED() << "Attempting to remove an item not in the list";
       return;
     }
 
     if (iteration_depth_ == 0) {
@@ skipping 170 matching lines @@
 
   // See description above setter.
   bool check_on_null_data_;
 
   base::SequenceChecker sequence_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(IDMap);
 };
 
 #endif  // BASE_ID_MAP_H_