Push preg_parser and registry_dict changes upstream

components/policy/core/common/registry_dict.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/registry_dict_win.h"
+#include "components/policy/core/common/registry_dict.h"
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/values.h"
+
+#if defined(OS_WIN)
 #include "base/win/registry.h"
 #include "components/policy/core/common/schema.h"
 
 using base::win::RegistryKeyIterator;
 using base::win::RegistryValueIterator;
+#endif  // #if defined(OS_WIN)
 
 namespace policy {
 
 namespace {
 
+#if defined(OS_WIN)
 // Validates that a key is numerical. Used for lists below.
 bool IsKeyNumerical(const std::string& key) {
   int temp = 0;
   return base::StringToInt(key, &temp);
 }
 
 // Converts a value (as read from the registry) to meet |schema|, converting
 // types as necessary. Unconvertible types will show up as null values in the
 // result.
 std::unique_ptr<base::Value> ConvertValue(const base::Value& value,
@@ skipping 17 matching lines @@
           result->SetWithoutPathExpansion(entry.key(), converted.release());
       }
       return std::move(result);
     } else if (value.GetAsList(&list)) {
       std::unique_ptr<base::ListValue> result(new base::ListValue());
       for (base::ListValue::const_iterator entry(list->begin());
            entry != list->end(); ++entry) {
         std::unique_ptr<base::Value> converted =
             ConvertValue(**entry, schema.GetItems());
         if (converted)
-          result->Append(converted.release());
+          result->Append(std::move(converted));
       }
       return std::move(result);
     }
     return value.CreateDeepCopy();
   }
 
   // Else, do some conversions to map windows registry data types to JSON types.
   std::string string_value;
   int int_value = 0;
   switch (schema.type()) {
@@ skipping 36 matching lines @@
       const base::DictionaryValue* dict = nullptr;
       if (value.GetAsDictionary(&dict)) {
         std::unique_ptr<base::ListValue> result(new base::ListValue());
         for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
              it.Advance()) {
           if (!IsKeyNumerical(it.key()))
             continue;
           std::unique_ptr<base::Value> converted =
               ConvertValue(it.value(), schema.GetItems());
           if (converted)
-            result->Append(converted.release());
+            result->Append(std::move(converted));
         }
         return std::move(result);
       }
       // Fall through in order to accept lists encoded as JSON strings.
     }
     case base::Value::TYPE_DICTIONARY: {
       // Dictionaries may be encoded as JSON strings.
       if (value.GetAsString(&string_value)) {
         std::unique_ptr<base::Value> result =
             base::JSONReader::Read(string_value);
         if (result && result->IsType(schema.type()))
           return result;
       }
       break;
     }
     case base::Value::TYPE_STRING:
     case base::Value::TYPE_BINARY:
       // No conversion possible.
       break;
   }
 
   LOG(WARNING) << "Failed to convert " << value.GetType()
                << " to " << schema.type();
   return nullptr;
 }
+#endif  // #if defined(OS_WIN)
 
 }  // namespace
 
 bool CaseInsensitiveStringCompare::operator()(const std::string& a,
                                               const std::string& b) const {
   return base::CompareCaseInsensitiveASCII(a, b) < 0;
 }
 
 RegistryDict::RegistryDict() {}
 
@@ skipping 84 matching lines @@
        entry != other.values_.end(); ++entry) {
     SetValue(entry->first, entry->second->CreateDeepCopy());
   }
 }
 
 void RegistryDict::Swap(RegistryDict* other) {
   keys_.swap(other->keys_);
   values_.swap(other->values_);
 }
 
+#if defined(OS_WIN)
 void RegistryDict::ReadRegistry(HKEY hive, const base::string16& root) {
   ClearKeys();
   ClearValues();
 
   // First, read all the values of the key.
   for (RegistryValueIterator it(hive, root.c_str()); it.Valid(); ++it) {
     const std::string name = base::UTF16ToUTF8(it.Name());
     switch (it.Type()) {
       case REG_SZ:
       case REG_EXPAND_SZ:
@@ skipping 69 matching lines @@
     case base::Value::TYPE_LIST: {
       std::unique_ptr<base::ListValue> result(new base::ListValue());
       Schema item_schema = schema.valid() ? schema.GetItems() : Schema();
       for (RegistryDict::KeyMap::const_iterator entry(keys_.begin());
            entry != keys_.end(); ++entry) {
         if (!IsKeyNumerical(entry->first))
           continue;
         std::unique_ptr<base::Value> converted =
             entry->second->ConvertToJSON(item_schema);
         if (converted)
-          result->Append(converted.release());
+          result->Append(std::move(converted));
       }
       for (RegistryDict::ValueMap::const_iterator entry(values_.begin());
            entry != values_.end(); ++entry) {
         if (!IsKeyNumerical(entry->first))
           continue;
         std::unique_ptr<base::Value> converted =
             ConvertValue(*entry->second, item_schema);
         if (converted)
-          result->Append(converted.release());
+          result->Append(std::move(converted));
       }
       return std::move(result);
     }
     default:
       LOG(WARNING) << "Can't convert registry key to schema type " << type;
   }
 
   return nullptr;
 }
-
+#endif  // #if defined(OS_WIN)
 }  // namespace policy