Make base::Value::TYPE a scoped enum.

components/policy/core/common/schema.h

 // Copyright 2013 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 COMPONENTS_POLICY_CORE_COMMON_SCHEMA_H_
 #define COMPONENTS_POLICY_CORE_COMMON_SCHEMA_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 95 matching lines @@
   // the bool that |changed| pointed to to false before calling Normalize().
   // |changed| can be NULL and in that case no boolean will be set.
   // This function will also take the ownership of dropped base::Value and
   // destroy them.
   bool Normalize(base::Value* value,
                  SchemaOnErrorStrategy strategy,
                  std::string* error_path,
                  std::string* error,
                  bool* changed) const;
 
-  // Used to iterate over the known properties of TYPE_DICTIONARY schemas.
+  // Used to iterate over the known properties of Type::DICTIONARY schemas.
   class POLICY_EXPORT Iterator {
    public:
     Iterator(const scoped_refptr<const InternalStorage>& storage,
              const internal::PropertiesNode* node);
     Iterator(const Iterator& iterator);
     ~Iterator();
 
     Iterator& operator=(const Iterator& iterator);
 
     // The other methods must not be called if the iterator is at the end.
     bool IsAtEnd() const;
 
     // Advances the iterator to the next property.
     void Advance();
 
     // Returns the name of the current property.
     const char* key() const;
 
     // Returns the Schema for the current property. This Schema is always valid.
     Schema schema() const;
 
    private:
     scoped_refptr<const InternalStorage> storage_;
     const internal::PropertyNode* it_;
     const internal::PropertyNode* end_;
   };
 
-  // These methods should be called only if type() == TYPE_DICTIONARY,
+  // These methods should be called only if type() == Type::DICTIONARY,
   // otherwise invalid memory will be read. A CHECK is currently enforcing this.
 
   // Returns an iterator that goes over the named properties of this schema.
   // The returned iterator is at the beginning.
   Iterator GetPropertiesIterator() const;
 
   // Returns the Schema for the property named |key|. If |key| is not a known
   // property name then the returned Schema is not valid.
   Schema GetKnownProperty(const std::string& key) const;
 
@@ skipping 10 matching lines @@
   // GetMatchingProperties() instead.
   // TODO(binjin): Replace calls to this function with GetKnownProperty() or
   // GetMatchingProperties() and remove this later.
   Schema GetProperty(const std::string& key) const;
 
   // Returns all Schemas that are supposed to be validated against for |key|.
   // May be empty.
   SchemaList GetMatchingProperties(const std::string& key) const;
 
   // Returns the Schema for items of an array.
-  // This method should be called only if type() == TYPE_LIST,
+  // This method should be called only if type() == Type::LIST,
   // otherwise invalid memory will be read. A CHECK is currently enforcing this.
   Schema GetItems() const;
 
  private:
   // Builds a schema pointing to the inner structure of |storage|,
   // rooted at |node|.
   Schema(const scoped_refptr<const InternalStorage>& storage,
          const internal::SchemaNode* node);
 
   bool ValidateIntegerRestriction(int index, int value) const;
   bool ValidateStringRestriction(int index, const char* str) const;
 
   scoped_refptr<const InternalStorage> storage_;
   const internal::SchemaNode* node_;
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_SCHEMA_H_