Convert //net and //chromecast to std::unordered_*

chromecast/base/device_capabilities_impl.cc

 // Copyright 2015 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 "chromecast/base/device_capabilities_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 131 matching lines @@
   // Make sure that all observers have been removed at this point
   observer_list_->AssertEmpty();
 }
 
 void DeviceCapabilitiesImpl::Register(const std::string& key,
                                       Validator* validator) {
   DCHECK(IsValidRegisterKey(key));
   DCHECK(validator);
 
   base::AutoLock auto_lock(validation_lock_);
-  bool added =
-      validator_map_.add(key, base::WrapUnique(new ValidatorInfo(validator)))
-          .second;
   // Check that a validator has not already been registered for this key
-  DCHECK(added);
+  DCHECK_EQ(0u, validator_map_.count(key));
+  validator_map_[key] = base::WrapUnique(new ValidatorInfo(validator));

[davidben, 2016/04/11 19:27:58]

This technically changes behavior in the failed DCHECK case. If we want to
completely emulate the old behavior, it'd be:

  bool added = validator_map_.insert(std::make_pair(key, base::WrapUnique(new
ValidatorInfo(validator)))).second;
  DCHECK(added);

But that's a mouthful and there's a DCHECK, so I assumed this version is
preferable.

[lcwu1, 2016/04/11 21:43:03]

Yes, I like the new implementation better. Thanks for doing this.

lgtm

 }
 
 void DeviceCapabilitiesImpl::Unregister(const std::string& key,
                                         const Validator* validator) {
   base::AutoLock auto_lock(validation_lock_);
   auto validator_it = validator_map_.find(key);
   DCHECK(validator_it != validator_map_.end());
   // Check that validator being unregistered matches the original for |key|.
   // This prevents managers from accidentally unregistering incorrect
   // validators.
@@ skipping 153 matching lines @@
   }
 
   // Even though ObserverListThreadSafe notifications are always asynchronous
   // (posts task even if to same thread), no locks should be held at this point
   // in the code. This is just to be safe that no deadlocks occur if Observers
   // call DeviceCapabilities methods in OnCapabilitiesChanged().
   observer_list_->Notify(FROM_HERE, &Observer::OnCapabilitiesChanged, path);
 }
 
 }  // namespace chromecast