Make the internal storage of policy::Schemas ref counted.

chrome/browser/policy/policy_domain_descriptor_unittest.cc

 // Copyright (c) 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 "chrome/browser/policy/policy_domain_descriptor.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 18 matching lines @@
                               std::string()));
 }
 
 TEST_F(PolicyDomainDescriptorTest, FilterBundle) {
   scoped_refptr<PolicyDomainDescriptor> descriptor =
       new PolicyDomainDescriptor(POLICY_DOMAIN_EXTENSIONS);
   EXPECT_EQ(POLICY_DOMAIN_EXTENSIONS, descriptor->domain());
   EXPECT_TRUE(descriptor->components().empty());
 
   std::string error;
-  scoped_ptr<SchemaOwner> schema = SchemaOwner::Parse(
+  Schema schema = Schema::Parse(
       "{"
       "  \"type\":\"object\","
       "  \"properties\": {"
       "    \"Array\": {"
       "      \"type\": \"array\","
       "      \"items\": { \"type\": \"string\" }"
       "    },"
       "    \"Boolean\": { \"type\": \"boolean\" },"
       "    \"Integer\": { \"type\": \"integer\" },"
       "    \"Null\": { \"type\": \"null\" },"
       "    \"Number\": { \"type\": \"number\" },"
       "    \"Object\": {"
       "      \"type\": \"object\","
       "      \"properties\": {"
       "        \"a\": { \"type\": \"string\" },"
       "        \"b\": { \"type\": \"integer\" }"
       "      }"
       "    },"
       "    \"String\": { \"type\": \"string\" }"
       "  }"
       "}", &error);
-  ASSERT_TRUE(schema) << error;
+  ASSERT_TRUE(schema.valid()) << error;
 
-  descriptor->RegisterComponent("abc", schema.Pass());
+  descriptor->RegisterComponent("abc", schema);
 
   EXPECT_EQ(1u, descriptor->components().size());
   EXPECT_EQ(1u, descriptor->components().count("abc"));
 
   PolicyBundle bundle;
   descriptor->FilterBundle(&bundle);
   const PolicyBundle empty_bundle;
   EXPECT_TRUE(bundle.Equals(empty_bundle));
 
   // Other namespaces aren't filtered.
@@ skipping 71 matching lines @@
   EXPECT_TRUE(bundle.Equals(empty_bundle));
 }
 
 TEST_F(PolicyDomainDescriptorTest, LegacyComponents) {
   scoped_refptr<PolicyDomainDescriptor> descriptor =
       new PolicyDomainDescriptor(POLICY_DOMAIN_EXTENSIONS);
   EXPECT_EQ(POLICY_DOMAIN_EXTENSIONS, descriptor->domain());
   EXPECT_TRUE(descriptor->components().empty());
 
   std::string error;
-  scoped_ptr<SchemaOwner> schema = SchemaOwner::Parse(
+  Schema schema = Schema::Parse(
       "{"
       "  \"type\":\"object\","
       "  \"properties\": {"
       "    \"String\": { \"type\": \"string\" }"
       "  }"
       "}", &error);
-  ASSERT_TRUE(schema) << error;
+  ASSERT_TRUE(schema.valid()) << error;
 
-  descriptor->RegisterComponent("with-schema", schema.Pass());
-  descriptor->RegisterComponent("without-schema", scoped_ptr<SchemaOwner>());
+  descriptor->RegisterComponent("with-schema", schema);
+  descriptor->RegisterComponent("without-schema", Schema());
 
   EXPECT_EQ(2u, descriptor->components().size());
 
   // |bundle| contains policies loaded by a policy provider.
   PolicyBundle bundle;
 
   // Known components with schemas are filtered.
   PolicyNamespace extension_ns(POLICY_DOMAIN_EXTENSIONS, "with-schema");
   bundle.Get(extension_ns).Set("String",
                                POLICY_LEVEL_MANDATORY,
@@ skipping 33 matching lines @@
                              POLICY_LEVEL_MANDATORY,
                              POLICY_SCOPE_USER,
                              base::Value::CreateStringValue("value 5"),
                              NULL);
 
   descriptor->FilterBundle(&bundle);
   EXPECT_TRUE(bundle.Equals(expected_bundle));
 }
 
 }  // namespace policy