Refactoring DeviceCapabilities unit test.

chromecast/base/device_capabilities.h

 // 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.
 
 #ifndef CHROMECAST_BASE_DEVICE_CAPABILITIES_H_
 #define CHROMECAST_BASE_DEVICE_CAPABILITIES_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 86 matching lines @@
   // The instance should be created early enough for all managers to register
   // themselves, and then live long enough for all managers to unregister.
   static scoped_ptr<DeviceCapabilities> Create();
   // Creates an instance where all the default capabilities are initialized
   // to a predefined default value, and no Validators are registered. For use
   // only in unit tests.
   static scoped_ptr<DeviceCapabilities> CreateForTesting();
 
   // Registers a Validator for a capability. A given key must only be
   // registered once, and must be unregistered before calling Register() again.
-  // The capability also gets added to the class with an initial value passed
-  // in. If the capability has a value of Dictionary type, |key| must be just
+  // If the capability has a value of Dictionary type, |key| must be just
   // the capability's top-level key and not include path expansions to levels
   // farther down. For example, "foo" is a valid value for |key|, but "foo.bar"
   // is not. Note that if "foo.bar" is updated in SetCapability(), the
   // Validate() method for "foo"'s Validator will be called, with a |path| of
   // "foo.bar". Both Register() and Unregister() must be called on cast
   // receiver main thread; the Validator provided will also be called on cast
-  // receiver main thread.
+  // receiver main thread. Note that this method does not add or modify
+  // the capability. To do this, SetCapability() should be called, or
+  // Validators can call SetValidatedValue().
   virtual void Register(const std::string& key,
-                        scoped_ptr<base::Value> init_value,
                         Validator* validator) = 0;
-  // Unregisters Validator for |key| and removes capability. |validator|
-  // argument must match |validator| argument that was passed in to Register()
-  // for |key|.
+  // Unregisters Validator for |key|. |validator| argument must match
+  // |validator| argument that was passed in to Register() for |key|. Note that
+  // the capability and its value remain untouched.
   virtual void Unregister(const std::string& key,
                           const Validator* validator) = 0;
+  // Gets the Validator currently registered for |key|. Returns nullptr if
+  // no Validator is registered.
+  virtual Validator* GetValidator(const std::string& key) const = 0;
 
   // Accessors for default capabilities. Note that the capability must be added
-  // through Register() or SetCapability() before accessors are called.
+  // through SetCapability() or SetValidatedValue() (for Validators) before
+  // accessors are called.
   virtual bool BluetoothSupported() const = 0;
   virtual bool DisplaySupported() const = 0;
 
   // Gets the value of |path|. If capability at |path| does not exist,
   // |out_value| remains untouched. Returns true if the capability has been
   // successfully retrieved. Note that this does NOT perform a deep copy, and
   // DeviceCapabilities still owns the memory returned through |out_value|.
   virtual bool GetCapability(const std::string& path,
                              const base::Value** out_value) const = 0;
 
@@ skipping 28 matching lines @@
   // Does actual internal update of |path| to |new_value|.
   virtual void SetValidatedValueInternal(const std::string& path,
                                          scoped_ptr<base::Value> new_value) = 0;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceCapabilities);
 };
 
 }  // namespace chromecast
 
 #endif  // CHROMECAST_BASE_DEVICE_CAPABILITIES_H_