Push preg_parser and registry_dict changes upstream

components/policy/core/common/registry_dict_unittest.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 <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/policy/core/common/schema.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
@@ skipping 161 matching lines @@
 
   EXPECT_TRUE(base::Value::Equals(&int_value, dict_b.GetValue("one")));
   EXPECT_TRUE(dict_b.GetKey("two"));
   EXPECT_FALSE(dict_b.GetValue("two"));
 
   EXPECT_TRUE(base::Value::Equals(&string_value, dict_a.GetValue("three")));
   EXPECT_FALSE(dict_a.GetValue("one"));
   EXPECT_FALSE(dict_a.GetKey("two"));
 }
 
+#if defined(OS_WIN)
 TEST(RegistryDictTest, ConvertToJSON) {
   RegistryDict test_dict;
 
   base::FundamentalValue int_value(42);
   base::StringValue string_value("fortytwo");
   base::StringValue string_zero("0");
   base::StringValue string_dict("{ \"key\": [ \"value\" ] }");
 
   test_dict.SetValue("one", int_value.CreateDeepCopy());
   std::unique_ptr<RegistryDict> subdict(new RegistryDict());
@@ skipping 40 matching lines @@
   std::unique_ptr<base::ListValue> expected_list(new base::ListValue());
   expected_list->Append(string_value.CreateDeepCopy());
   expected.Set("dict-to-list", std::move(expected_list));
   expected.Set("int-to-bool", new base::FundamentalValue(true));
   expected.Set("int-to-double", new base::FundamentalValue(42.0));
   expected.Set("string-to-bool", new base::FundamentalValue(false));
   expected.Set("string-to-double", new base::FundamentalValue(0.0));
   expected.Set("string-to-int",
                new base::FundamentalValue(static_cast<int>(0)));
   expected_list.reset(new base::ListValue());
-  expected_list->Append(new base::StringValue("value"));
+  expected_list->Append(base::MakeUnique<base::StringValue>("value"));
   expected_subdict.reset(new base::DictionaryValue());
   expected_subdict->Set("key", std::move(expected_list));
   expected.Set("string-to-dict", std::move(expected_subdict));
 
   EXPECT_TRUE(base::Value::Equals(actual.get(), &expected));
 }
 
 TEST(RegistryDictTest, NonSequentialConvertToJSON) {
   RegistryDict test_dict;
 
@@ skipping 22 matching lines @@
 
   base::DictionaryValue expected;
   std::unique_ptr<base::ListValue> expected_list(new base::ListValue());
   expected_list->Append(base::StringValue("1").CreateDeepCopy());
   expected_list->Append(base::StringValue("2").CreateDeepCopy());
   expected_list->Append(base::StringValue("4").CreateDeepCopy());
   expected.Set("dict-to-list", std::move(expected_list));
 
   EXPECT_TRUE(base::Value::Equals(actual.get(), &expected));
 }
+#endif
 
 TEST(RegistryDictTest, KeyValueNameClashes) {
   RegistryDict test_dict;
 
   base::FundamentalValue int_value(42);
   base::StringValue string_value("fortytwo");
 
   test_dict.SetValue("one", int_value.CreateDeepCopy());
   std::unique_ptr<RegistryDict> subdict(new RegistryDict());
   subdict->SetValue("two", string_value.CreateDeepCopy());
   test_dict.SetKey("one", std::move(subdict));
 
   EXPECT_TRUE(base::Value::Equals(&int_value, test_dict.GetValue("one")));
   RegistryDict* actual_subdict = test_dict.GetKey("one");
   ASSERT_TRUE(actual_subdict);
   EXPECT_TRUE(base::Value::Equals(&string_value,
                                   actual_subdict->GetValue("two")));
 }
 
 }  // namespace
 }  // namespace policy