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

components/policy/core/common/schema_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/schema.h"
 
 #include "components/policy/core/common/schema_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
 #define OBJECT_TYPE "\"type\":\"object\""
 
 bool ParseFails(const std::string& content) {
   std::string error;
-  scoped_ptr<SchemaOwner> schema = SchemaOwner::Parse(content, &error);
-  if (schema)
-    EXPECT_TRUE(schema->schema().valid());
-  else
-    EXPECT_FALSE(error.empty());
-  return !schema;
+  Schema schema = Schema::Parse(content, &error);
+  if (schema.valid())
+    return false;
+  EXPECT_FALSE(error.empty());
+  return true;
 }
 
 }  // namespace
 
 TEST(SchemaTest, MinimalSchema) {
   EXPECT_FALSE(ParseFails(
       "{"
         OBJECT_TYPE
       "}"));
 }
@@ skipping 31 matching lines @@
         "\"properties\": { \"Policy\": { \"type\": [\"string\", \"number\"] } }"
       "}"));
 
   EXPECT_TRUE(ParseFails(
       "{"
         OBJECT_TYPE ","
         "\"properties\": { \"Policy\": { \"type\": \"any\" } }"
       "}"));
 }
 
+TEST(SchemaTest, Ownership) {
+  std::string error;
+  Schema schema = Schema::Parse(
+      "{"
+        OBJECT_TYPE ","
+        "\"properties\": {"
+          "\"sub\": {"
+            "\"type\": \"object\","
+            "\"properties\": {"
+              "\"subsub\": { \"type\": \"string\" }"
+            "}"
+          "}"
+        "}"
+      "}", &error);
+  ASSERT_TRUE(schema.valid()) << error;
+  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+
+  schema = schema.GetKnownProperty("sub");
+  ASSERT_TRUE(schema.valid());
+  ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
+
+  {
+    Schema::Iterator it = schema.GetPropertiesIterator();
+    ASSERT_FALSE(it.IsAtEnd());
+    EXPECT_STREQ("subsub", it.key());
+
+    schema = it.schema();
+    it.Advance();
+    EXPECT_TRUE(it.IsAtEnd());
+  }
+
+  ASSERT_TRUE(schema.valid());
+  EXPECT_EQ(base::Value::TYPE_STRING, schema.type());
+
+  // This test shouldn't leak nor use invalid memory.
+}
+
 TEST(SchemaTest, ValidSchema) {
   std::string error;
-  scoped_ptr<SchemaOwner> policy_schema = SchemaOwner::Parse(
+  Schema schema = Schema::Parse(
       "{"
         OBJECT_TYPE ","
         "\"properties\": {"
         "  \"Boolean\": { \"type\": \"boolean\" },"
         "  \"Integer\": { \"type\": \"integer\" },"
         "  \"Null\": { \"type\": \"null\" },"
         "  \"Number\": { \"type\": \"number\" },"
         "  \"String\": { \"type\": \"string\" },"
         "  \"Array\": {"
         "    \"type\": \"array\","
@@ skipping 19 matching lines @@
         "  \"Object\": {"
         "    \"type\": \"object\","
         "    \"properties\": {"
         "      \"one\": { \"type\": \"boolean\" },"
         "      \"two\": { \"type\": \"integer\" }"
         "    },"
         "    \"additionalProperties\": { \"type\": \"string\" }"
         "  }"
         "}"
       "}", &error);
-  ASSERT_TRUE(policy_schema) << error;
-  ASSERT_TRUE(policy_schema->schema().valid());
+  ASSERT_TRUE(schema.valid()) << error;
 
-  Schema schema = policy_schema->schema();
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
   EXPECT_FALSE(schema.GetProperty("invalid").valid());
 
   Schema sub = schema.GetProperty("Boolean");
   ASSERT_TRUE(sub.valid());
   EXPECT_EQ(base::Value::TYPE_BOOLEAN, sub.type());
 
   sub = schema.GetProperty("Integer");
   ASSERT_TRUE(sub.valid());
   EXPECT_EQ(base::Value::TYPE_INTEGER, sub.type());
@@ skipping 75 matching lines @@
     EXPECT_STREQ(kExpectedProperties[i].expected_key, it.key());
     ASSERT_TRUE(it.schema().valid());
     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
     it.Advance();
   }
   EXPECT_TRUE(it.IsAtEnd());
 }
 
 TEST(SchemaTest, Lookups) {
   std::string error;
-  scoped_ptr<SchemaOwner> policy_schema = SchemaOwner::Parse(
+
+  Schema schema = Schema::Parse(
       "{"
         OBJECT_TYPE
       "}", &error);
-  ASSERT_TRUE(policy_schema) << error;
-  Schema schema = policy_schema->schema();
-  ASSERT_TRUE(schema.valid());
+  ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   // This empty schema should never find named properties.
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetPropertiesIterator().IsAtEnd());
 
-  policy_schema = SchemaOwner::Parse(
+  schema = Schema::Parse(
       "{"
         OBJECT_TYPE ","
         "\"properties\": {"
         "  \"Boolean\": { \"type\": \"boolean\" }"
         "}"
       "}", &error);
-  ASSERT_TRUE(policy_schema) << error;
-  schema = policy_schema->schema();
-  ASSERT_TRUE(schema.valid());
+  ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
   EXPECT_TRUE(schema.GetKnownProperty("Boolean").valid());
 
-  policy_schema = SchemaOwner::Parse(
+  schema = Schema::Parse(
       "{"
         OBJECT_TYPE ","
         "\"properties\": {"
           "  \"bb\" : { \"type\": \"null\" },"
           "  \"aa\" : { \"type\": \"boolean\" },"
           "  \"abab\" : { \"type\": \"string\" },"
           "  \"ab\" : { \"type\": \"number\" },"
           "  \"aba\" : { \"type\": \"integer\" }"
         "}"
       "}", &error);
-  ASSERT_TRUE(policy_schema) << error;
-  schema = policy_schema->schema();
-  ASSERT_TRUE(schema.valid());
+  ASSERT_TRUE(schema.valid()) << error;
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   EXPECT_FALSE(schema.GetKnownProperty("").valid());
   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 
   struct {
     const char* expected_key;
     base::Value::Type expected_type;
   } kExpectedKeys[] = {
     { "aa",     base::Value::TYPE_BOOLEAN },
@@ skipping 33 matching lines @@
     // SchemaNode offset 6 is for additionalProperties (list of lists).
     { 0, 5, 6 },
   };
 
   const internal::SchemaData kData = {
     kSchemas,
     kPropertyNodes,
     kProperties,
   };
 
-  scoped_ptr<SchemaOwner> policy_schema = SchemaOwner::Wrap(&kData);
-  ASSERT_TRUE(policy_schema);
-  Schema schema = policy_schema->schema();
+  Schema schema = Schema::Wrap(&kData);
   ASSERT_TRUE(schema.valid());
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 
   struct {
     const char* key;
     base::Value::Type type;
   } kExpectedProperties[] = {
     { "Boolean", base::Value::TYPE_BOOLEAN },
     { "Integer", base::Value::TYPE_INTEGER },
     { "Number", base::Value::TYPE_DOUBLE },
@@ skipping 25 matching lines @@
   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
   Schema subsub = sub.GetItems();
   ASSERT_TRUE(subsub.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, subsub.type());
   Schema subsubsub = subsub.GetItems();
   ASSERT_TRUE(subsubsub.valid());
   ASSERT_EQ(base::Value::TYPE_STRING, subsubsub.type());
 }
 
 }  // namespace policy