diff --git a/DIR_METADATA b/DIR_METADATA
new file mode 100644
index 0000000..507a6ca
--- /dev/null
+++ b/DIR_METADATA
@@ -0,0 +1,3 @@
+monorail {
+  component: "Internals>Plugins>PDF"
+}
diff --git a/OWNERS b/OWNERS
index adb56ef..a7896f5 100644
--- a/OWNERS
+++ b/OWNERS
@@ -10,5 +10,3 @@
 
 # For Skia related changes
 reed@google.com
-
-# COMPONENT: Internals>Plugins>PDF
diff --git a/third_party/base/allocator/partition_allocator/DIR_METADATA b/third_party/base/allocator/partition_allocator/DIR_METADATA
new file mode 100644
index 0000000..296c22b
--- /dev/null
+++ b/third_party/base/allocator/partition_allocator/DIR_METADATA
@@ -0,0 +1,5 @@
+monorail {
+  component: "Blink>MemoryAllocator>Partition"
+}
+// Also: security-dev@chromium.org
+team_email: "platform-architecture-dev@chromium.org"
diff --git a/third_party/base/allocator/partition_allocator/OWNERS b/third_party/base/allocator/partition_allocator/OWNERS
index b0a2a85..5845072 100644
--- a/third_party/base/allocator/partition_allocator/OWNERS
+++ b/third_party/base/allocator/partition_allocator/OWNERS
@@ -3,6 +3,3 @@
 palmer@chromium.org
 tsepez@chromium.org
 
-# TEAM: platform-architecture-dev@chromium.org
-#       Also: security-dev@chromium.org
-# COMPONENT: Blink>MemoryAllocator>Partition
