Refactoring DeviceCapabilities unit test.

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 "base/logging.h"
 #include "base/values.h"
 #include "chromecast/base/serializers.h"
 
@@ skipping 65 matching lines @@
   DCHECK(capabilities_str_.get());
 }
 
 DeviceCapabilitiesImpl::~DeviceCapabilitiesImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Make sure that any registered Validators have unregistered at this point
   DCHECK(validator_map_.empty());
 }
 
 void DeviceCapabilitiesImpl::Register(const std::string& key,
-                                      scoped_ptr<base::Value> init_value,
                                       Validator* validator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidRegisterKey(key));
-  DCHECK(init_value.get());
   DCHECK(validator);
 
-  AddValidator(key, validator);
-
-  capabilities_->Set(key, init_value.Pass());
-  UpdateStrAndNotifyChanged(key);
+  bool added = validator_map_.insert(std::make_pair(key, validator)).second;
+  // Check that a validator has not already been registered for this key
+  DCHECK(added);
 }
 
 void DeviceCapabilitiesImpl::Unregister(const std::string& key,
                                         const Validator* validator) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  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.
-  DCHECK_EQ(validator, validator_it->second);
-  validator_map_.erase(validator_it);
+  DCHECK_EQ(validator, GetValidator(key));
+  bool erased = validator_map_.erase(key);
+  DCHECK(erased);
+}
 
-  bool removed = capabilities_->Remove(key, nullptr);
-  DCHECK(removed);
-  UpdateStrAndNotifyChanged(key);
+DeviceCapabilities::Validator* DeviceCapabilitiesImpl::GetValidator(
+    const std::string& key) const {
+  auto validator_it = validator_map_.find(key);
+  return validator_it == validator_map_.end() ? nullptr : validator_it->second;
 }
 
 bool DeviceCapabilitiesImpl::BluetoothSupported() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool bluetooth_supported = false;
   bool found_key =
       capabilities_->GetBoolean(kKeyBluetoothSupported, &bluetooth_supported);
   DCHECK(found_key);
   return bluetooth_supported;
 }
@@ skipping 78 matching lines @@
       GetCapability(path, &cur_value) && cur_value->Equals(new_value.get());
   if (capability_unchaged) {
     VLOG(1) << "Ignoring unchanged capability: " << path;
     return;
   }
 
   capabilities_->Set(path, new_value.Pass());
   UpdateStrAndNotifyChanged(path);
 }
 
-void DeviceCapabilitiesImpl::AddValidator(const std::string& key,
-                                          Validator* validator) {
-  DCHECK(validator);
-  bool added = validator_map_.insert(std::make_pair(key, validator)).second;
-  // Check that a validator has not already been registered for this key
-  DCHECK(added);
-}
-
 void DeviceCapabilitiesImpl::UpdateStrAndNotifyChanged(
     const std::string& path) {
   // Update capabilities string here since all updates to capabilities must
   // ultimately call this method no matter where the update originated from.
   capabilities_str_ = SerializeToJson(*capabilities_);
   DCHECK(capabilities_str_.get());
   FOR_EACH_OBSERVER(Observer, observer_list_, OnCapabilitiesChanged(path));
 }
 
 }  // namespace chromecast