Add touch flag to output of Schema::Normalize()

components/policy/core/common/schema.cc

 // 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.
 
 #include "components/policy/core/common/schema.h"
 
 #include <algorithm>
 #include <climits>
 #include <map>
 #include <utility>
@@ skipping 719 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 bool Schema::Normalize(base::Value* value,
                        SchemaOnErrorStrategy strategy,
                        std::string* error_path,
-                       std::string* error) const {
+                       std::string* error,
+                       bool* changed) const {
   if (!valid()) {
     SchemaErrorFound(error_path, error, "The schema is invalid.");
     return false;
   }
 
   if (!value->IsType(type())) {
     // Allow the integer to double promotion. Note that range restriction on
     // double is not supported now.
     if (value->IsType(base::Value::TYPE_INTEGER) &&
         type() == base::Value::TYPE_DOUBLE) {
@@ skipping 18 matching lines @@
         if (StrategyAllowUnknownOnTopLevel(strategy))
           drop_list.push_back(it.key());
         else
           return false;
       } else {
         base::Value* sub_value = NULL;
         dict->GetWithoutPathExpansion(it.key(), &sub_value);
         if (!subschema.Normalize(sub_value,
                                  StrategyForNextLevel(strategy),
                                  error_path,
-                                 error)) {
+                                 error,
+                                 changed)) {
           // Invalid property was detected.
           AddDictKeyPrefixToPath(it.key(), error_path);
           if (StrategyAllowInvalidOnTopLevel(strategy))
             drop_list.push_back(it.key());
           else
             return false;
         }
       }
     }
+    if (changed && !drop_list.empty())
+      *changed = true;
     for (std::vector<std::string>::const_iterator it = drop_list.begin();
          it != drop_list.end();
          ++it) {
       dict->RemoveWithoutPathExpansion(*it, NULL);
     }
     return true;
   } else if (value->GetAsList(&list)) {
     std::vector<size_t> drop_list;  // Contains the indexes to drop.
     for (size_t index = 0; index < list->GetSize(); index++) {
       base::Value* sub_value = NULL;
       list->Get(index, &sub_value);
-      if (!sub_value ||
-          !GetItems().Normalize(sub_value,
-                                StrategyForNextLevel(strategy),
-                                error_path,
-                                error)) {
+      if (!sub_value || !GetItems().Normalize(sub_value,
+                                              StrategyForNextLevel(strategy),
+                                              error_path,
+                                              error,
+                                              changed)) {
         // Invalid list item was detected.
         AddListIndexPrefixToPath(index, error_path);
         if (StrategyAllowInvalidOnTopLevel(strategy))
           drop_list.push_back(index);
         else
           return false;
       }
     }
+    if (changed && !drop_list.empty())
+      *changed = true;
     for (std::vector<size_t>::reverse_iterator it = drop_list.rbegin();
          it != drop_list.rend(); ++it) {
       list->Remove(*it, NULL);
     }
     return true;
   }
 
   return Validate(*value, strategy, error_path, error);
 }
 
@@ skipping 103 matching lines @@
   const RestrictionNode* rnode = storage_->restriction(index);
   for (int i = rnode->enumeration_restriction.offset_begin;
        i < rnode->enumeration_restriction.offset_end; i++) {
     if (strcmp(*storage_->string_enums(i), str) == 0)
       return true;
   }
   return false;
 }
 
 }  // namespace policy