Merge changes from topic "nov11"

* changes:
  Mechanical refactoring to new XML resolvers.
  Mechanical refactoring to new XML resolvers.
  Progress towards efficient XML serialization.

57 files changed, 1108 insertions, 334 deletions

diff --git a/errorprone/java/com/google/errorprone/bugpatterns/android/EfficientXmlChecker.java b/errorprone/java/com/google/errorprone/bugpatterns/android/EfficientXmlChecker.java
new file mode 100644
index 000000000000..b5f26e7dc9dd
--- /dev/null
+++ b/errorprone/java/com/google/errorprone/bugpatterns/android/EfficientXmlChecker.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.errorprone.bugpatterns.android;
+
+import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.matchers.Matchers.anyOf;
+import static com.google.errorprone.matchers.Matchers.instanceMethod;
+import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
+import static com.google.errorprone.matchers.Matchers.methodInvocation;
+import static com.google.errorprone.matchers.Matchers.staticMethod;
+import static com.google.errorprone.matchers.Matchers.stringLiteral;
+
+import com.google.auto.service.AutoService;
+import com.google.common.base.Objects;
+import com.google.errorprone.BugPattern;
+import com.google.errorprone.VisitorState;
+import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
+import com.google.errorprone.bugpatterns.BugChecker.NewClassTreeMatcher;
+import com.google.errorprone.matchers.Description;
+import com.google.errorprone.matchers.Matcher;
+import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.AssignmentTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.IdentifierTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.NewClassTree;
+import com.sun.source.tree.Tree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.TreePathScanner;
+import com.sun.tools.javac.code.Type;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+import javax.lang.model.element.Name;
+
+/**
+ * Android offers {@code TypedXmlSerializer} and {@code TypedXmlPullParser} to
+ * more efficiently store primitive values.
+ * <p>
+ * This checker identifies callers that are manually converting strings instead
+ * of relying on efficient strongly-typed methods.
+ */
+@AutoService(BugChecker.class)
+@BugPattern(
+    name = "AndroidFrameworkEfficientXml",
+    summary = "Verifies efficient XML best-practices",
+    severity = WARNING)
+public final class EfficientXmlChecker extends BugChecker
+        implements MethodInvocationTreeMatcher, NewClassTreeMatcher {
+    private static final String STRING = "java.lang.String";
+    private static final String INTEGER = "java.lang.Integer";
+    private static final String LONG = "java.lang.Long";
+    private static final String FLOAT = "java.lang.Float";
+    private static final String DOUBLE = "java.lang.Double";
+    private static final String BOOLEAN = "java.lang.Boolean";
+
+    private static final Matcher<ExpressionTree> BOOLEAN_STRING_LITERAL = stringLiteral(
+            Pattern.compile("(true|false)"));
+
+    private static final Matcher<ExpressionTree> PRIMITIVE_TO_STRING = anyOf(
+            methodInvocation(staticMethod().onClass(INTEGER).named("toString")),
+            methodInvocation(staticMethod().onClass(INTEGER).named("toHexString")),
+            methodInvocation(staticMethod().onClass(LONG).named("toString")),
+            methodInvocation(staticMethod().onClass(LONG).named("toHexString")),
+            methodInvocation(staticMethod().onClass(FLOAT).named("toString")),
+            methodInvocation(staticMethod().onClass(DOUBLE).named("toString")),
+            methodInvocation(staticMethod().onClass(BOOLEAN).named("toString")),
+            methodInvocation(instanceMethod().onExactClass(INTEGER).named("toString")),
+            methodInvocation(instanceMethod().onExactClass(LONG).named("toString")),
+            methodInvocation(instanceMethod().onExactClass(FLOAT).named("toString")),
+            methodInvocation(instanceMethod().onExactClass(DOUBLE).named("toString")),
+            methodInvocation(instanceMethod().onExactClass(BOOLEAN).named("toString")));
+
+    private static final Matcher<ExpressionTree> VALUE_OF_PRIMITIVE = anyOf(
+            methodInvocation(staticMethod().onClass(STRING).withSignature("valueOf(int)")),
+            methodInvocation(staticMethod().onClass(STRING).withSignature("valueOf(long)")),
+            methodInvocation(staticMethod().onClass(STRING).withSignature("valueOf(float)")),
+            methodInvocation(staticMethod().onClass(STRING).withSignature("valueOf(double)")),
+            methodInvocation(staticMethod().onClass(STRING).withSignature("valueOf(boolean)")));
+
+    private static final Matcher<ExpressionTree> VALUE_OF_OBJECT = methodInvocation(
+            staticMethod().onClass(STRING).withSignature("valueOf(java.lang.Object)"));
+
+    private static final Matcher<ExpressionTree> PRIMITIVE_PARSE = anyOf(
+            methodInvocation(staticMethod().onClass(INTEGER).named("parseInt")),
+            methodInvocation(staticMethod().onClass(INTEGER)
+                    .withSignature("valueOf(java.lang.String)")),
+            methodInvocation(staticMethod().onClass(INTEGER)
+                    .withSignature("valueOf(java.lang.String,int)")),
+            methodInvocation(staticMethod().onClass(LONG).named("parseLong")),
+            methodInvocation(staticMethod().onClass(LONG)
+                    .withSignature("valueOf(java.lang.String)")),
+            methodInvocation(staticMethod().onClass(LONG)
+                    .withSignature("valueOf(java.lang.String,int)")),
+            methodInvocation(staticMethod().onClass(FLOAT).named("parseFloat")),
+            methodInvocation(staticMethod().onClass(FLOAT)
+                    .withSignature("valueOf(java.lang.String)")),
+            methodInvocation(staticMethod().onClass(DOUBLE).named("parseDouble")),
+            methodInvocation(staticMethod().onClass(DOUBLE)
+                    .withSignature("valueOf(java.lang.String)")),
+            methodInvocation(staticMethod().onClass(BOOLEAN).named("parseBoolean")),
+            methodInvocation(staticMethod().onClass(BOOLEAN)
+                    .withSignature("valueOf(java.lang.String)")));
+
+    private static final Matcher<Tree> IS_FAST_XML_SERIALIZER =
+            isSubtypeOf("com.android.internal.util.FastXmlSerializer");
+
+    private static final Matcher<ExpressionTree> WRITE_ATTRIBUTE = methodInvocation(
+            instanceMethod().onDescendantOf("org.xmlpull.v1.XmlSerializer")
+                    .named("attribute"));
+
+    private static final Matcher<ExpressionTree> READ_ATTRIBUTE = methodInvocation(
+            instanceMethod().onDescendantOf("org.xmlpull.v1.XmlPullParser")
+                    .named("getAttributeValue"));
+
+    private static final Matcher<ExpressionTree> XML_FACTORY = methodInvocation(staticMethod()
+            .onClass("android.util.Xml").namedAnyOf("newSerializer", "newPullParser"));
+
+    private static final Matcher<ExpressionTree> BYTES_TO_STRING = anyOf(
+            methodInvocation(staticMethod().onClass("android.util.Base64")
+                    .named("encodeToString")),
+            methodInvocation(instanceMethod().onDescendantOf("java.util.Base64.Encoder")
+                    .named("encodeToString")),
+            methodInvocation(staticMethod().onClass("libcore.util.HexEncoding")
+                    .named("encodeToString")),
+            methodInvocation(staticMethod().onClass("com.android.internal.util.HexDump")
+                    .named("toHexString")));
+
+    private static final Matcher<ExpressionTree> BYTES_FROM_STRING = anyOf(
+            methodInvocation(staticMethod().onClass("android.util.Base64")
+                    .named("decode")),
+            methodInvocation(instanceMethod().onDescendantOf("java.util.Base64.Decoder")
+                    .named("decode")),
+            methodInvocation(staticMethod().onClass("libcore.util.HexEncoding")
+                    .named("decode")),
+            methodInvocation(staticMethod().onClass("com.android.internal.util.HexDump")
+                    .named("hexStringToByteArray")));
+
+    private static final String MESSAGE_WRITE = "Primitive values can be written more "
+            + "efficiently by using TypedXmlSerializer overloads";
+    private static final String MESSAGE_READ = "Primitive values can be parsed more "
+            + "efficiently by using TypedXmlPullParser overloads";
+    private static final String MESSAGE_CTOR = "Primitive values can be parsed more "
+            + "efficiently by using Xml.resolveSerializer() and/or Xml.resolvePullParser()";
+
+    /**
+     * Determine if the given expression is attempting to convert a primitive to
+     * a {@link String}.
+     */
+    private static final Matcher<ExpressionTree> CONVERT_PRIMITIVE_TO_STRING =
+            new Matcher<ExpressionTree>() {
+        @Override
+        public boolean matches(ExpressionTree tree, VisitorState state) {
+            if (PRIMITIVE_TO_STRING.matches(tree, state)) {
+                final List<? extends ExpressionTree> args = ((MethodInvocationTree) tree)
+                        .getArguments();
+                // We're only interested in base-10 or base-16 numerical conversions
+                if (args.size() <= 1 || String.valueOf(args.get(1)).equals("10")
+                        || String.valueOf(args.get(1)).equals("16")) {
+                    return true;
+                }
+            } else if (VALUE_OF_PRIMITIVE.matches(tree, state)) {
+                return true;
+            } else if (VALUE_OF_OBJECT.matches(tree, state)) {
+                final Type type = ASTHelpers.getResultType(((MethodInvocationTree) tree)
+                        .getArguments().get(0));
+                if (ASTHelpers.isSameType(type, state.getTypeFromString(INTEGER), state)
+                        || ASTHelpers.isSameType(type, state.getTypeFromString(LONG), state)
+                        || ASTHelpers.isSameType(type, state.getTypeFromString(FLOAT), state)
+                        || ASTHelpers.isSameType(type, state.getTypeFromString(DOUBLE), state)
+                        || ASTHelpers.isSameType(type, state.getTypeFromString(BOOLEAN), state)) {
+                    return true;
+                }
+            } else if (BOOLEAN_STRING_LITERAL.matches(tree, state)) {
+                return true;
+            } else if (BYTES_TO_STRING.matches(tree, state)) {
+                return true;
+            }
+            return false;
+        }
+    };
+
+    /**
+     * Determine if the given expression is attempting to convert a
+     * {@link String} to a primitive.
+     */
+    private static final Matcher<ExpressionTree> CONVERT_STRING_TO_PRIMITIVE =
+            new Matcher<ExpressionTree>() {
+        @Override
+        public boolean matches(ExpressionTree tree, VisitorState state) {
+            if (PRIMITIVE_PARSE.matches(tree, state)) {
+                final List<? extends ExpressionTree> args = ((MethodInvocationTree) tree)
+                        .getArguments();
+                // We're only interested in base-10 or base-16 numerical conversions
+                if (args.size() <= 1 || String.valueOf(args.get(1)).equals("10")
+                        || String.valueOf(args.get(1)).equals("16")) {
+                    return true;
+                }
+            } else if (BYTES_FROM_STRING.matches(tree, state)) {
+                return true;
+            }
+            return false;
+        }
+    };
+
+    @Override
+    public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
+        if (WRITE_ATTRIBUTE.matches(tree, state)) {
+            final List<? extends ExpressionTree> args = tree.getArguments();
+            final ExpressionTree writeSource = args.get(2);
+            if (CONVERT_PRIMITIVE_TO_STRING.matches(writeSource, state)) {
+                return buildDescription(tree).setMessage(MESSAGE_WRITE).build();
+            }
+
+            // Hunt around for related conversions
+            if (writeSource instanceof IdentifierTree) {
+                final Name name = ((IdentifierTree) writeSource).getName();
+                final Description res = new TreePathScanner<Description, Void>() {
+                    @Override
+                    public Description reduce(Description r1, Description r2) {
+                        return (r1 != null) ? r1 : r2;
+                    }
+
+                    @Override
+                    public Description visitVariable(VariableTree node, Void param) {
+                        return visitWriteSource(node.getName(), node.getInitializer());
+                    }
+
+                    @Override
+                    public Description visitAssignment(AssignmentTree node, Void param) {
+                        final ExpressionTree variable = node.getVariable();
+                        if (variable instanceof IdentifierTree) {
+                            return visitWriteSource(((IdentifierTree) variable).getName(),
+                                    node.getExpression());
+                        } else {
+                            return super.visitAssignment(node, param);
+                        }
+                    }
+
+                    private Description visitWriteSource(Name target, ExpressionTree source) {
+                        if (CONVERT_PRIMITIVE_TO_STRING.matches(source, state)
+                                && Objects.equal(name, target)) {
+                            return buildDescription(source).setMessage(MESSAGE_WRITE).build();
+                        } else {
+                            return null;
+                        }
+                    }
+                }.scan(state.findPathToEnclosing(MethodTree.class), null);
+                if (res != null) {
+                    return res;
+                }
+            }
+        } else if (READ_ATTRIBUTE.matches(tree, state)) {
+            final Tree readDest = state.getPath().getParentPath().getLeaf();
+            if (readDest instanceof ExpressionTree
+                    && CONVERT_STRING_TO_PRIMITIVE.matches((ExpressionTree) readDest, state)) {
+                return buildDescription(tree).setMessage(MESSAGE_READ).build();
+            }
+
+            // Hunt around for related conversions
+            Name name = null;
+            if (readDest instanceof VariableTree) {
+                name = ((VariableTree) readDest).getName();
+            } else if (readDest instanceof AssignmentTree) {
+                final ExpressionTree variable = ((AssignmentTree) readDest).getVariable();
+                if (variable instanceof IdentifierTree) {
+                    name = ((IdentifierTree) variable).getName();
+                }
+            }
+            if (name != null) {
+                final Name fName = name;
+                final Description res = new TreePathScanner<Description, Void>() {
+                    @Override
+                    public Description reduce(Description r1, Description r2) {
+                        return (r1 != null) ? r1 : r2;
+                    }
+
+                    @Override
+                    public Description visitMethodInvocation(MethodInvocationTree node,
+                            Void param) {
+                        if (CONVERT_STRING_TO_PRIMITIVE.matches(node, state)) {
+                            final ExpressionTree arg = node.getArguments().get(0);
+                            if (arg instanceof IdentifierTree
+                                    && Objects.equal(((IdentifierTree) arg).getName(), fName)) {
+                                return buildDescription(node).setMessage(MESSAGE_READ).build();
+                            }
+                        }
+                        return super.visitMethodInvocation(node, param);
+                    }
+                }.scan(state.findPathToEnclosing(MethodTree.class), null);
+                if (res != null) {
+                    return res;
+                }
+            }
+        } else if (XML_FACTORY.matches(tree, state)) {
+            return buildDescription(tree).setMessage(MESSAGE_CTOR).build();
+        }
+        return Description.NO_MATCH;
+    }
+
+    @Override
+    public Description matchNewClass(NewClassTree tree, VisitorState state) {
+        if (IS_FAST_XML_SERIALIZER.matches(tree, state)) {
+            return buildDescription(tree).setMessage(MESSAGE_CTOR).build();
+        }
+        return Description.NO_MATCH;
+    }
+}
diff --git a/errorprone/tests/java/com/google/errorprone/bugpatterns/android/EfficientXmlCheckerTest.java b/errorprone/tests/java/com/google/errorprone/bugpatterns/android/EfficientXmlCheckerTest.java
new file mode 100644
index 000000000000..084fb255ed7b
--- /dev/null
+++ b/errorprone/tests/java/com/google/errorprone/bugpatterns/android/EfficientXmlCheckerTest.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.errorprone.bugpatterns.android;
+
+import com.google.errorprone.CompilationTestHelper;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class EfficientXmlCheckerTest {
+    private CompilationTestHelper compilationHelper;
+
+    @Before
+    public void setUp() {
+        compilationHelper = CompilationTestHelper.newInstance(
+                EfficientXmlChecker.class, getClass());
+    }
+
+    @Test
+    public void testCtor() {
+        compilationHelper
+                .addSourceFile("/android/util/Xml.java")
+                .addSourceFile("/com/android/internal/util/FastXmlSerializer.java")
+                .addSourceLines("Example.java",
+                        "import android.util.Xml;",
+                        "import com.android.internal.util.FastXmlSerializer;",
+                        "public class Example {",
+                        "  public void writer() throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    Xml.newSerializer();",
+                        "    // BUG: Diagnostic contains:",
+                        "    new FastXmlSerializer();",
+                        "  }",
+                        "  public void reader() throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    Xml.newPullParser();",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testWrite() {
+        compilationHelper
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlSerializer;",
+                        "public class Example {",
+                        "  public void typical(XmlSerializer out) throws Exception {",
+                        "    out.attribute(null, null, null);",
+                        "    out.attribute(null, null, \"foo\");",
+                        "    out.attribute(null, null, String.valueOf(null));",
+                        "    out.attribute(null, null, String.valueOf(\"foo\"));",
+                        "  }",
+                        "  public void rawBoolean(XmlSerializer out) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, \"true\");",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, \"false\");",
+                        "  }",
+                        "  public void toString(XmlSerializer out) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Integer.toString(42));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Integer.toString(42, 10));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Integer.toString(42, 16));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Integer.toHexString(42));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Long.toString(42L));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Long.toString(42L, 10));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Long.toString(42L, 16));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Long.toHexString(42L));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Float.toString(42f));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Double.toString(42d));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Boolean.toString(true));",
+                        "  }",
+                        "  public void toStringBoxed(XmlSerializer out) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Integer.valueOf(42).toString());",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Long.valueOf(42L).toString());",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Float.valueOf(42f).toString());",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Double.valueOf(42d).toString());",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Boolean.valueOf(true).toString());",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, Boolean.TRUE.toString());",
+                        "  }",
+                        "  public void valueOf(XmlSerializer out) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(42));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(42L));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(42f));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(42d));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(true));",
+                        "  }",
+                        "  public void valueOfBoxed(XmlSerializer out) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Integer.valueOf(42)));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Long.valueOf(42L)));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Float.valueOf(42f)));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Double.valueOf(42d)));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Boolean.valueOf(true)));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null, String.valueOf(Boolean.TRUE));",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testWrite_Indirect() {
+        compilationHelper
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlSerializer;",
+                        "public class Example {",
+                        "  XmlSerializer out;",
+                        "  public void argUnknown(String arg) throws Exception {",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "  public void argNull(String arg) throws Exception {",
+                        "    arg = null;",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "  public void argValueOfNull(String arg) throws Exception {",
+                        "    arg = String.valueOf(null);",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "  public void argToString(String arg) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    arg = Integer.toString(42);",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "  public void argValueOf(String arg) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    arg = String.valueOf(42);",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "  public void directToString() throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    String arg = Integer.toString(42);",
+                        "    out.attribute(null, null, arg);",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testWrite_Bytes() {
+        compilationHelper
+                .addSourceFile("/android/util/Base64.java")
+                .addSourceFile("/libcore/util/HexEncoding.java")
+                .addSourceFile("/com/android/internal/util/HexDump.java")
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlSerializer;",
+                        "public class Example {",
+                        "  XmlSerializer out;",
+                        "  public void bytes(byte[] arg) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null,",
+                        "        android.util.Base64.encodeToString(arg, 0));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null,",
+                        "        java.util.Base64.getEncoder().encodeToString(arg));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null,",
+                        "        libcore.util.HexEncoding.encodeToString(arg));",
+                        "    // BUG: Diagnostic contains:",
+                        "    out.attribute(null, null,",
+                        "        com.android.internal.util.HexDump.toHexString(arg));",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testRead() {
+        compilationHelper
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlPullParser;",
+                        "public class Example {",
+                        "  public void typical(XmlPullParser in) throws Exception {",
+                        "    in.getAttributeValue(null, null);",
+                        "  }",
+                        "  public void parse(XmlPullParser in) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    Integer.parseInt(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Integer.parseInt(in.getAttributeValue(null, null), 10);",
+                        "    // BUG: Diagnostic contains:",
+                        "    Integer.parseInt(in.getAttributeValue(null, null), 16);",
+                        "    // BUG: Diagnostic contains:",
+                        "    Long.parseLong(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Long.parseLong(in.getAttributeValue(null, null), 10);",
+                        "    // BUG: Diagnostic contains:",
+                        "    Long.parseLong(in.getAttributeValue(null, null), 16);",
+                        "    // BUG: Diagnostic contains:",
+                        "    Float.parseFloat(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Double.parseDouble(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Boolean.parseBoolean(in.getAttributeValue(null, null));",
+                        "  }",
+                        "  public void valueOf(XmlPullParser in) throws Exception {",
+                        "    // BUG: Diagnostic contains:",
+                        "    Integer.valueOf(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Long.valueOf(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Float.valueOf(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Double.valueOf(in.getAttributeValue(null, null));",
+                        "    // BUG: Diagnostic contains:",
+                        "    Boolean.valueOf(in.getAttributeValue(null, null));",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testRead_Indirect() {
+        compilationHelper
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlPullParser;",
+                        "public class Example {",
+                        "  public int direct(XmlPullParser in) throws Exception {",
+                        "    String arg = in.getAttributeValue(null, null);",
+                        "    if (arg != null) {",
+                        "      // BUG: Diagnostic contains:",
+                        "      return Integer.parseInt(arg);",
+                        "    } else {",
+                        "      return -1;",
+                        "    }",
+                        "  }",
+                        "  public int indirect(XmlPullParser in, String arg) throws Exception {",
+                        "    arg = in.getAttributeValue(null, null);",
+                        "    if (arg != null) {",
+                        "      // BUG: Diagnostic contains:",
+                        "      return Integer.parseInt(arg);",
+                        "    } else {",
+                        "      return -1;",
+                        "    }",
+                        "  }",
+                        "  public int tryCatch(XmlPullParser in) throws Exception {",
+                        "    String arg = in.getAttributeValue(null, null);",
+                        "    try {",
+                        "      // BUG: Diagnostic contains:",
+                        "      return Integer.parseInt(arg);",
+                        "    } catch (NumberFormatException e) {",
+                        "      return -1;",
+                        "    }",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
+    @Test
+    public void testRead_Bytes() {
+        compilationHelper
+                .addSourceFile("/android/util/Base64.java")
+                .addSourceFile("/libcore/util/HexEncoding.java")
+                .addSourceFile("/com/android/internal/util/HexDump.java")
+                .addSourceLines("Example.java",
+                        "import org.xmlpull.v1.XmlPullParser;",
+                        "public class Example {",
+                        "  XmlPullParser in;",
+                        "  public void bytes() throws Exception {",
+                        "    android.util.Base64.decode(",
+                        "        // BUG: Diagnostic contains:",
+                        "        in.getAttributeValue(null, null), 0);",
+                        "    java.util.Base64.getDecoder().decode(",
+                        "        // BUG: Diagnostic contains:",
+                        "        in.getAttributeValue(null, null));",
+                        "    libcore.util.HexEncoding.decode(",
+                        "        // BUG: Diagnostic contains:",
+                        "        in.getAttributeValue(null, null));",
+                        "    com.android.internal.util.HexDump.hexStringToByteArray(",
+                        "        // BUG: Diagnostic contains:",
+                        "        in.getAttributeValue(null, null));",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+}
diff --git a/errorprone/tests/res/android/util/Base64.java b/errorprone/tests/res/android/util/Base64.java
new file mode 100644
index 000000000000..63d80befd750
--- /dev/null
+++ b/errorprone/tests/res/android/util/Base64.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.util;
+
+public class Base64 {
+    public static byte[] decode(String str, int flags) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static String encodeToString(byte[] input, int flags) {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/errorprone/tests/res/android/util/Xml.java b/errorprone/tests/res/android/util/Xml.java
new file mode 100644
index 000000000000..0e44d00f4812
--- /dev/null
+++ b/errorprone/tests/res/android/util/Xml.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.util;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlSerializer;
+
+public class Xml {
+    public static XmlPullParser newPullParser() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static XmlSerializer newSerializer() {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/errorprone/tests/res/com/android/internal/util/FastXmlSerializer.java b/errorprone/tests/res/com/android/internal/util/FastXmlSerializer.java
new file mode 100644
index 000000000000..83d14a9a3c64
--- /dev/null
+++ b/errorprone/tests/res/com/android/internal/util/FastXmlSerializer.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.util;
+
+public class FastXmlSerializer {
+}
diff --git a/errorprone/tests/res/com/android/internal/util/HexDump.java b/errorprone/tests/res/com/android/internal/util/HexDump.java
new file mode 100644
index 000000000000..55d3e50cc7bb
--- /dev/null
+++ b/errorprone/tests/res/com/android/internal/util/HexDump.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.util;
+
+public class HexDump {
+    public static String toHexString(byte[] array) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static byte[] hexStringToByteArray(String hexString) {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/errorprone/tests/res/libcore/util/HexEncoding.java b/errorprone/tests/res/libcore/util/HexEncoding.java
new file mode 100644
index 000000000000..34bbbaca4c1d
--- /dev/null
+++ b/errorprone/tests/res/libcore/util/HexEncoding.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.util;
+
+public class HexEncoding {
+    public static String encodeToString(byte[] data) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static byte[] decode(String encoded) {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/services/appwidget/java/com/android/server/appwidget/AppWidgetServiceImpl.java b/services/appwidget/java/com/android/server/appwidget/AppWidgetServiceImpl.java
index 1c4d752c9775..f1988e9f8b6b 100644
--- a/services/appwidget/java/com/android/server/appwidget/AppWidgetServiceImpl.java
+++ b/services/appwidget/java/com/android/server/appwidget/AppWidgetServiceImpl.java
@@ -95,6 +95,8 @@ import android.util.SparseArray;
 import android.util.SparseIntArray;
 import android.util.SparseLongArray;
 import android.util.TypedValue;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.util.proto.ProtoOutputStream;
 import android.view.Display;
@@ -3075,8 +3077,7 @@ class AppWidgetServiceImpl extends IAppWidgetService.Stub implements WidgetBacku
         int N;
 
         try {
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
             out.startTag(null, "gs");
             out.attribute(null, "version", String.valueOf(CURRENT_VERSION));
@@ -3138,8 +3139,7 @@ class AppWidgetServiceImpl extends IAppWidgetService.Stub implements WidgetBacku
             List<LoadedWidgetState> outLoadedWidgets) {
         int version = -1;
         try {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
             int legacyProviderIndex = -1;
             int legacyHostIndex = -1;
diff --git a/services/core/java/com/android/server/PackageWatchdog.java b/services/core/java/com/android/server/PackageWatchdog.java
index f07954609603..735d248b12e4 100644
--- a/services/core/java/com/android/server/PackageWatchdog.java
+++ b/services/core/java/com/android/server/PackageWatchdog.java
@@ -40,6 +40,8 @@ import android.util.AtomicFile;
 import android.util.LongArrayQueue;
 import android.util.MathUtils;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -934,8 +936,7 @@ public class PackageWatchdog {
         mAllObservers.clear();
         try {
             infile = mPolicyFile.openRead();
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(infile, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(infile);
             XmlUtils.beginDocument(parser, TAG_PACKAGE_WATCHDOG);
             int outerDepth = parser.getDepth();
             while (XmlUtils.nextElementWithin(parser, outerDepth)) {
@@ -1027,8 +1028,7 @@ public class PackageWatchdog {
             }
 
             try {
-                XmlSerializer out = new FastXmlSerializer();
-                out.setOutput(stream, StandardCharsets.UTF_8.name());
+                TypedXmlSerializer out = Xml.resolveSerializer(stream);
                 out.startDocument(null, true);
                 out.startTag(null, TAG_PACKAGE_WATCHDOG);
                 out.attribute(null, ATTR_VERSION, Integer.toString(DB_VERSION));
diff --git a/services/core/java/com/android/server/SensorPrivacyService.java b/services/core/java/com/android/server/SensorPrivacyService.java
index edeb049c0802..2455e76d69a8 100644
--- a/services/core/java/com/android/server/SensorPrivacyService.java
+++ b/services/core/java/com/android/server/SensorPrivacyService.java
@@ -30,6 +30,8 @@ import android.os.RemoteException;
 import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -101,9 +103,8 @@ public final class SensorPrivacyService extends SystemService {
                 mEnabled = enable;
                 FileOutputStream outputStream = null;
                 try {
-                    XmlSerializer serializer = new FastXmlSerializer();
                     outputStream = mAtomicFile.startWrite();
-                    serializer.setOutput(outputStream, StandardCharsets.UTF_8.name());
+                    TypedXmlSerializer serializer = Xml.resolveSerializer(outputStream);
                     serializer.startDocument(null, true);
                     serializer.startTag(null, XML_TAG_SENSOR_PRIVACY);
                     serializer.attribute(null, XML_ATTRIBUTE_ENABLED, String.valueOf(enable));
@@ -153,8 +154,7 @@ public final class SensorPrivacyService extends SystemService {
             }
             boolean enabled;
             try (FileInputStream inputStream = mAtomicFile.openRead()) {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(inputStream, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
                 XmlUtils.beginDocument(parser, XML_TAG_SENSOR_PRIVACY);
                 parser.next();
                 String tagName = parser.getName();
@@ -176,9 +176,8 @@ public final class SensorPrivacyService extends SystemService {
             synchronized (mLock) {
                 FileOutputStream outputStream = null;
                 try {
-                    XmlSerializer serializer = new FastXmlSerializer();
                     outputStream = mAtomicFile.startWrite();
-                    serializer.setOutput(outputStream, StandardCharsets.UTF_8.name());
+                    TypedXmlSerializer serializer = Xml.resolveSerializer(outputStream);
                     serializer.startDocument(null, true);
                     serializer.startTag(null, XML_TAG_SENSOR_PRIVACY);
                     serializer.attribute(null, XML_ATTRIBUTE_ENABLED, String.valueOf(mEnabled));
diff --git a/services/core/java/com/android/server/StorageManagerService.java b/services/core/java/com/android/server/StorageManagerService.java
index ab933a8c2be8..783866ab3420 100644
--- a/services/core/java/com/android/server/StorageManagerService.java
+++ b/services/core/java/com/android/server/StorageManagerService.java
@@ -130,6 +130,8 @@ import android.util.Log;
 import android.util.Pair;
 import android.util.Slog;
 import android.util.TimeUtils;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -2023,8 +2025,7 @@ class StorageManagerService extends IStorageManager.Stub
         FileInputStream fis = null;
         try {
             fis = mSettingsFile.openRead();
-            final XmlPullParser in = Xml.newPullParser();
-            in.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser in = Xml.resolvePullParser(fis);
 
             int type;
             while ((type = in.next()) != END_DOCUMENT) {
@@ -2063,8 +2064,7 @@ class StorageManagerService extends IStorageManager.Stub
         try {
             fos = mSettingsFile.startWrite();
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.startTag(null, TAG_VOLUMES);
             writeIntAttribute(out, ATTR_VERSION, VERSION_FIX_PRIMARY);
diff --git a/services/core/java/com/android/server/SystemUpdateManagerService.java b/services/core/java/com/android/server/SystemUpdateManagerService.java
index 6c1ffdd32d18..61a7d00faeb8 100644
--- a/services/core/java/com/android/server/SystemUpdateManagerService.java
+++ b/services/core/java/com/android/server/SystemUpdateManagerService.java
@@ -38,6 +38,8 @@ import android.os.SystemUpdateManager;
 import android.provider.Settings;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.util.FastXmlSerializer;
@@ -130,8 +132,7 @@ public class SystemUpdateManagerService extends ISystemUpdateManager.Stub {
     private Bundle loadSystemUpdateInfoLocked() {
         PersistableBundle loadedBundle = null;
         try (FileInputStream fis = mFile.openRead()) {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             loadedBundle = readInfoFileLocked(parser);
         } catch (FileNotFoundException e) {
             Slog.i(TAG, "No existing info file " + mFile.getBaseFile());
@@ -216,8 +217,7 @@ public class SystemUpdateManagerService extends ISystemUpdateManager.Stub {
         try {
             fos = mFile.startWrite();
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
 
             out.startTag(null, TAG_INFO);
diff --git a/services/core/java/com/android/server/adb/AdbDebuggingManager.java b/services/core/java/com/android/server/adb/AdbDebuggingManager.java
index ed83a644cbfb..f59af76ead8f 100644
--- a/services/core/java/com/android/server/adb/AdbDebuggingManager.java
+++ b/services/core/java/com/android/server/adb/AdbDebuggingManager.java
@@ -64,6 +64,8 @@ import android.service.adb.AdbDebuggingManagerProto;
 import android.util.AtomicFile;
 import android.util.Base64;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.R;
@@ -1935,8 +1937,7 @@ public class AdbDebuggingManager {
                 return keyMap;
             }
             try (FileInputStream keyStream = mAtomicKeyFile.openRead()) {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(keyStream, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(keyStream);
                 // Check for supported keystore version.
                 XmlUtils.beginDocument(parser, XML_KEYSTORE_START_TAG);
                 if (parser.next() != XmlPullParser.END_DOCUMENT) {
@@ -2007,8 +2008,7 @@ public class AdbDebuggingManager {
                 return keyMap;
             }
             try (FileInputStream keyStream = mAtomicKeyFile.openRead()) {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(keyStream, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(keyStream);
                 XmlUtils.beginDocument(parser, XML_TAG_ADB_KEY);
                 while (parser.next() != XmlPullParser.END_DOCUMENT) {
                     String tagName = parser.getName();
@@ -2058,8 +2058,7 @@ public class AdbDebuggingManager {
                 return trustedNetworks;
             }
             try (FileInputStream keyStream = mAtomicKeyFile.openRead()) {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(keyStream, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(keyStream);
                 // Check for supported keystore version.
                 XmlUtils.beginDocument(parser, XML_KEYSTORE_START_TAG);
                 if (parser.next() != XmlPullParser.END_DOCUMENT) {
@@ -2144,9 +2143,8 @@ public class AdbDebuggingManager {
             }
             FileOutputStream keyStream = null;
             try {
-                XmlSerializer serializer = new FastXmlSerializer();
                 keyStream = mAtomicKeyFile.startWrite();
-                serializer.setOutput(keyStream, StandardCharsets.UTF_8.name());
+                TypedXmlSerializer serializer = Xml.resolveSerializer(keyStream);
                 serializer.startDocument(null, true);
 
                 serializer.startTag(null, XML_KEYSTORE_START_TAG);
diff --git a/services/core/java/com/android/server/appop/AppOpsService.java b/services/core/java/com/android/server/appop/AppOpsService.java
index 0b2628d0f80b..09937e3a74c1 100644
--- a/services/core/java/com/android/server/appop/AppOpsService.java
+++ b/services/core/java/com/android/server/appop/AppOpsService.java
@@ -141,6 +141,8 @@ import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
 import android.util.TimeUtils;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -4291,8 +4293,7 @@ public class AppOpsService extends IAppOpsService.Stub {
                 boolean success = false;
                 mUidStates.clear();
                 try {
-                    XmlPullParser parser = Xml.newPullParser();
-                    parser.setInput(stream, StandardCharsets.UTF_8.name());
+                    TypedXmlPullParser parser = Xml.resolvePullParser(stream);
                     int type;
                     while ((type = parser.next()) != XmlPullParser.START_TAG
                             && type != XmlPullParser.END_DOCUMENT) {
@@ -4550,8 +4551,7 @@ public class AppOpsService extends IAppOpsService.Stub {
             List<AppOpsManager.PackageOps> allOps = getPackagesForOps(null);
 
             try {
-                XmlSerializer out = new FastXmlSerializer();
-                out.setOutput(stream, StandardCharsets.UTF_8.name());
+                TypedXmlSerializer out = Xml.resolveSerializer(stream);
                 out.startDocument(null, true);
                 out.startTag(null, "app-ops");
                 out.attribute(null, "v", String.valueOf(CURRENT_VERSION));
diff --git a/services/core/java/com/android/server/content/SyncStorageEngine.java b/services/core/java/com/android/server/content/SyncStorageEngine.java
index e9c4b510039d..9a1f1e522f97 100644
--- a/services/core/java/com/android/server/content/SyncStorageEngine.java
+++ b/services/core/java/com/android/server/content/SyncStorageEngine.java
@@ -50,6 +50,8 @@ import android.util.Log;
 import android.util.Pair;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.util.proto.ProtoInputStream;
 import android.util.proto.ProtoOutputStream;
@@ -1635,8 +1637,7 @@ public class SyncStorageEngine {
             if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
                 Slog.v(TAG_FILE, "Reading " + mAccountInfoFile.getBaseFile());
             }
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             int eventType = parser.getEventType();
             while (eventType != XmlPullParser.START_TAG &&
                     eventType != XmlPullParser.END_DOCUMENT) {
@@ -1988,8 +1989,7 @@ public class SyncStorageEngine {
 
         try {
             fos = mAccountInfoFile.startWrite();
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
diff --git a/services/core/java/com/android/server/display/AmbientBrightnessStatsTracker.java b/services/core/java/com/android/server/display/AmbientBrightnessStatsTracker.java
index 6e571bd75946..928799b31df8 100644
--- a/services/core/java/com/android/server/display/AmbientBrightnessStatsTracker.java
+++ b/services/core/java/com/android/server/display/AmbientBrightnessStatsTracker.java
@@ -22,6 +22,8 @@ import android.hardware.display.AmbientBrightnessDayStats;
 import android.os.SystemClock;
 import android.os.UserManager;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -165,8 +167,7 @@ public class AmbientBrightnessStatsTracker {
         }
 
         public void writeToXML(OutputStream stream) throws IOException {
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -206,8 +207,7 @@ public class AmbientBrightnessStatsTracker {
         public void readFromXML(InputStream stream) throws IOException {
             try {
                 Map<Integer, Deque<AmbientBrightnessDayStats>> parsedStats = new HashMap<>();
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(stream, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
                 int type;
                 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
diff --git a/services/core/java/com/android/server/display/BrightnessTracker.java b/services/core/java/com/android/server/display/BrightnessTracker.java
index 9e82d4fe6233..3ae99ef3ed5e 100644
--- a/services/core/java/com/android/server/display/BrightnessTracker.java
+++ b/services/core/java/com/android/server/display/BrightnessTracker.java
@@ -55,6 +55,8 @@ import android.os.UserManager;
 import android.provider.Settings;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.Display;
 
@@ -536,8 +538,7 @@ public class BrightnessTracker {
     @VisibleForTesting
     @GuardedBy("mEventsLock")
     void writeEventsLocked(OutputStream stream) throws IOException {
-        XmlSerializer out = new FastXmlSerializer();
-        out.setOutput(stream, StandardCharsets.UTF_8.name());
+        TypedXmlSerializer out = Xml.resolveSerializer(stream);
         out.startDocument(null, true);
         out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -607,8 +608,7 @@ public class BrightnessTracker {
     @GuardedBy("mEventsLock")
     void readEventsLocked(InputStream stream) throws IOException {
         try {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
             int type;
             while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
diff --git a/services/core/java/com/android/server/display/PersistentDataStore.java b/services/core/java/com/android/server/display/PersistentDataStore.java
index 09b0b3a8dee2..494dd397b1e9 100644
--- a/services/core/java/com/android/server/display/PersistentDataStore.java
+++ b/services/core/java/com/android/server/display/PersistentDataStore.java
@@ -25,6 +25,7 @@ import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseLongArray;
 import android.util.TimeUtils;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.Display;
 
@@ -323,8 +324,7 @@ final class PersistentDataStore {
 
         XmlPullParser parser;
         try {
-            parser = Xml.newPullParser();
-            parser.setInput(new BufferedInputStream(is), StandardCharsets.UTF_8.name());
+            parser = Xml.resolvePullParser(is);
             loadFromXml(parser);
         } catch (IOException ex) {
             Slog.w(TAG, "Failed to load display manager persistent store data.", ex);
@@ -343,8 +343,7 @@ final class PersistentDataStore {
             os = mInjector.startWrite();
             boolean success = false;
             try {
-                XmlSerializer serializer = new FastXmlSerializer();
-                serializer.setOutput(new BufferedOutputStream(os), StandardCharsets.UTF_8.name());
+                TypedXmlSerializer serializer = Xml.resolveSerializer(os);
                 saveToXml(serializer);
                 serializer.flush();
                 success = true;
diff --git a/services/core/java/com/android/server/input/PersistentDataStore.java b/services/core/java/com/android/server/input/PersistentDataStore.java
index 196787aa5cda..f61662d34e75 100644
--- a/services/core/java/com/android/server/input/PersistentDataStore.java
+++ b/services/core/java/com/android/server/input/PersistentDataStore.java
@@ -29,6 +29,8 @@ import android.view.Surface;
 import android.hardware.input.TouchCalibration;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import java.io.BufferedInputStream;
@@ -214,10 +216,9 @@ final class PersistentDataStore {
             return;
         }
 
-        XmlPullParser parser;
+        TypedXmlPullParser parser;
         try {
-            parser = Xml.newPullParser();
-            parser.setInput(new BufferedInputStream(is), StandardCharsets.UTF_8.name());
+            parser = Xml.resolvePullParser(is);
             loadFromXml(parser);
         } catch (IOException ex) {
             Slog.w(InputManagerService.TAG, "Failed to load input manager persistent store data.", ex);
@@ -236,8 +237,7 @@ final class PersistentDataStore {
             os = mAtomicFile.startWrite();
             boolean success = false;
             try {
-                XmlSerializer serializer = new FastXmlSerializer();
-                serializer.setOutput(new BufferedOutputStream(os), StandardCharsets.UTF_8.name());
+                TypedXmlSerializer serializer = Xml.resolveSerializer(os);
                 saveToXml(serializer);
                 serializer.flush();
                 success = true;
diff --git a/services/core/java/com/android/server/inputmethod/AdditionalSubtypeUtils.java b/services/core/java/com/android/server/inputmethod/AdditionalSubtypeUtils.java
index f79ac164ef55..a077b049b014 100644
--- a/services/core/java/com/android/server/inputmethod/AdditionalSubtypeUtils.java
+++ b/services/core/java/com/android/server/inputmethod/AdditionalSubtypeUtils.java
@@ -25,6 +25,8 @@ import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.InputMethodSubtype;
@@ -139,8 +141,7 @@ final class AdditionalSubtypeUtils {
         final AtomicFile subtypesFile = getAdditionalSubtypeFile(inputMethodDir);
         try {
             fos = subtypesFile.startWrite();
-            final XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
             out.startTag(null, NODE_SUBTYPES);
@@ -207,8 +208,7 @@ final class AdditionalSubtypeUtils {
             return;
         }
         try (FileInputStream fis = subtypesFile.openRead()) {
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             int type = parser.getEventType();
             // Skip parsing until START_TAG
             while (true) {
diff --git a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
index dd6c8f558354..a44ddcb03c16 100644
--- a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
+++ b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
@@ -217,6 +217,8 @@ import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
 import android.util.SparseLongArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.R;
@@ -2226,8 +2228,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
         FileInputStream fis = null;
         try {
             fis = mPolicyFile.openRead();
-            final XmlPullParser in = Xml.newPullParser();
-            in.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser in = Xml.resolvePullParser(fis);
 
              // Must save the <restrict-background> tags and convert them to <uid-policy> later,
              // to skip UIDs that were explicitly denylisted.
@@ -2496,8 +2497,7 @@ public class NetworkPolicyManagerService extends INetworkPolicyManager.Stub {
         try {
             fos = mPolicyFile.startWrite();
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
 
             out.startTag(null, TAG_POLICY_LIST);
diff --git a/services/core/java/com/android/server/net/watchlist/WatchlistSettings.java b/services/core/java/com/android/server/net/watchlist/WatchlistSettings.java
index c2f3ba01e3ec..4506b7d363db 100644
--- a/services/core/java/com/android/server/net/watchlist/WatchlistSettings.java
+++ b/services/core/java/com/android/server/net/watchlist/WatchlistSettings.java
@@ -20,6 +20,8 @@ import android.os.Environment;
 import android.util.AtomicFile;
 import android.util.Log;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -92,8 +94,7 @@ class WatchlistSettings {
             return;
         }
         try (FileInputStream stream = mXmlFile.openRead()){
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
             XmlUtils.beginDocument(parser, "network-watchlist-settings");
             final int outerDepth = parser.getDepth();
             while (XmlUtils.nextElementWithin(parser, outerDepth)) {
@@ -145,8 +146,7 @@ class WatchlistSettings {
             return;
         }
         try {
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
             out.startTag(null, "network-watchlist-settings");
             out.startTag(null, "secret-key");
diff --git a/services/core/java/com/android/server/om/OverlayManagerSettings.java b/services/core/java/com/android/server/om/OverlayManagerSettings.java
index 3d520bf59068..8a2d823cf7e9 100644
--- a/services/core/java/com/android/server/om/OverlayManagerSettings.java
+++ b/services/core/java/com/android/server/om/OverlayManagerSettings.java
@@ -25,6 +25,8 @@ import android.content.om.OverlayInfo;
 import android.os.UserHandle;
 import android.util.ArrayMap;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -405,10 +407,9 @@ final class OverlayManagerSettings {
         public static void restore(@NonNull final ArrayList<SettingsItem> table,
                 @NonNull final InputStream is) throws IOException, XmlPullParserException {
 
-            try (InputStreamReader reader = new InputStreamReader(is)) {
+            {
                 table.clear();
-                final XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(reader);
+                final TypedXmlPullParser parser = Xml.resolvePullParser(is);
                 XmlUtils.beginDocument(parser, TAG_OVERLAYS);
                 int version = XmlUtils.readIntAttribute(parser, ATTR_VERSION);
                 if (version != CURRENT_VERSION) {
@@ -465,8 +466,7 @@ final class OverlayManagerSettings {
 
         public static void persist(@NonNull final ArrayList<SettingsItem> table,
                 @NonNull final OutputStream os) throws IOException, XmlPullParserException {
-            final FastXmlSerializer xml = new FastXmlSerializer();
-            xml.setOutput(os, "utf-8");
+            final TypedXmlSerializer xml = Xml.resolveSerializer(os);
             xml.startDocument(null, true);
             xml.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
             xml.startTag(null, TAG_OVERLAYS);
@@ -481,7 +481,7 @@ final class OverlayManagerSettings {
             xml.endDocument();
         }
 
-        private static void persistRow(@NonNull final FastXmlSerializer xml,
+        private static void persistRow(@NonNull final TypedXmlSerializer xml,
                 @NonNull final SettingsItem item) throws IOException {
             xml.startTag(null, TAG_ITEM);
             XmlUtils.writeStringAttribute(xml, ATTR_PACKAGE_NAME, item.mPackageName);
diff --git a/services/core/java/com/android/server/pm/CrossProfileIntentFilter.java b/services/core/java/com/android/server/pm/CrossProfileIntentFilter.java
index ff4049bf2441..ea2439e5b596 100644
--- a/services/core/java/com/android/server/pm/CrossProfileIntentFilter.java
+++ b/services/core/java/com/android/server/pm/CrossProfileIntentFilter.java
@@ -16,14 +16,19 @@
 
 package com.android.server.pm;
 
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.UserHandle;
+import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
+
 import com.android.internal.util.XmlUtils;
+
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
-import android.content.IntentFilter;
-import android.util.Log;
+
 import java.io.IOException;
-import android.os.UserHandle;
 
 /**
  * The {@link PackageManagerService} maintains some {@link CrossProfileIntentFilter}s for each user.
@@ -63,7 +68,7 @@ class CrossProfileIntentFilter extends IntentFilter {
         return mOwnerPackage;
     }
 
-    CrossProfileIntentFilter(XmlPullParser parser) throws XmlPullParserException, IOException {
+    CrossProfileIntentFilter(TypedXmlPullParser parser) throws XmlPullParserException, IOException {
         mTargetUserId = getIntFromXml(parser, ATTR_TARGET_USER_ID, UserHandle.USER_NULL);
         mOwnerPackage = getStringFromXml(parser, ATTR_OWNER_PACKAGE, "");
         mFlags = getIntFromXml(parser, ATTR_FLAGS, 0);
@@ -98,7 +103,7 @@ class CrossProfileIntentFilter extends IntentFilter {
         }
     }
 
-    String getStringFromXml(XmlPullParser parser, String attribute, String defaultValue) {
+    String getStringFromXml(TypedXmlPullParser parser, String attribute, String defaultValue) {
         String value = parser.getAttributeValue(null, attribute);
         if (value == null) {
             String msg = "Missing element under " + TAG +": " + attribute + " at " +
@@ -110,7 +115,7 @@ class CrossProfileIntentFilter extends IntentFilter {
         }
     }
 
-    int getIntFromXml(XmlPullParser parser, String attribute, int defaultValue) {
+    int getIntFromXml(TypedXmlPullParser parser, String attribute, int defaultValue) {
         String stringValue = getStringFromXml(parser, attribute, null);
         if (stringValue != null) {
             return Integer.parseInt(stringValue);
@@ -118,7 +123,7 @@ class CrossProfileIntentFilter extends IntentFilter {
         return defaultValue;
     }
 
-    public void writeToXml(XmlSerializer serializer) throws IOException {
+    public void writeToXml(TypedXmlSerializer serializer) throws IOException {
         serializer.attribute(null, ATTR_TARGET_USER_ID, Integer.toString(mTargetUserId));
         serializer.attribute(null, ATTR_FLAGS, Integer.toString(mFlags));
         serializer.attribute(null, ATTR_OWNER_PACKAGE, mOwnerPackage);
diff --git a/services/core/java/com/android/server/pm/InstantAppRegistry.java b/services/core/java/com/android/server/pm/InstantAppRegistry.java
index efbdfeaaeb93..3f2c235153c1 100644
--- a/services/core/java/com/android/server/pm/InstantAppRegistry.java
+++ b/services/core/java/com/android/server/pm/InstantAppRegistry.java
@@ -43,6 +43,8 @@ import android.util.PackageUtils;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseBooleanArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -1020,8 +1022,7 @@ class InstantAppRegistry {
         final String packageName = instantDir.getName();
 
         try {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(in, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(in);
             return new UninstalledInstantAppState(
                     parseMetadata(parser, packageName), timestamp);
         } catch (XmlPullParserException | IOException e) {
@@ -1061,7 +1062,7 @@ class InstantAppRegistry {
     }
 
     private static @Nullable
-    InstantAppInfo parseMetadata(@NonNull XmlPullParser parser,
+    InstantAppInfo parseMetadata(@NonNull TypedXmlPullParser parser,
                                  @NonNull String packageName)
             throws IOException, XmlPullParserException {
         final int outerDepth = parser.getDepth();
@@ -1073,7 +1074,7 @@ class InstantAppRegistry {
         return null;
     }
 
-    private static InstantAppInfo parsePackage(@NonNull XmlPullParser parser,
+    private static InstantAppInfo parsePackage(@NonNull TypedXmlPullParser parser,
                                                @NonNull String packageName)
             throws IOException, XmlPullParserException {
         String label = parser.getAttributeValue(null, ATTR_LABEL);
@@ -1098,7 +1099,7 @@ class InstantAppRegistry {
                 requestedPermissions, grantedPermissions);
     }
 
-    private static void parsePermissions(@NonNull XmlPullParser parser,
+    private static void parsePermissions(@NonNull TypedXmlPullParser parser,
             @NonNull List<String> outRequestedPermissions,
             @NonNull List<String> outGrantedPermissions)
             throws IOException, XmlPullParserException {
@@ -1128,8 +1129,7 @@ class InstantAppRegistry {
         try {
             out = destination.startWrite();
 
-            XmlSerializer serializer = Xml.newSerializer();
-            serializer.setOutput(out, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer serializer = Xml.resolveSerializer(out);
             serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
             serializer.startDocument(null, true);
diff --git a/services/core/java/com/android/server/pm/KeySetManagerService.java b/services/core/java/com/android/server/pm/KeySetManagerService.java
index dabcc35103ba..86f024f4fce4 100644
--- a/services/core/java/com/android/server/pm/KeySetManagerService.java
+++ b/services/core/java/com/android/server/pm/KeySetManagerService.java
@@ -26,12 +26,13 @@ import android.util.ArraySet;
 import android.util.Base64;
 import android.util.LongSparseArray;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.server.pm.parsing.pkg.AndroidPackage;
 
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
 import java.io.IOException;
 import java.io.PrintWriter;
@@ -671,7 +672,7 @@ public class KeySetManagerService {
         }
     }
 
-    void writeKeySetManagerServiceLPr(XmlSerializer serializer) throws IOException {
+    void writeKeySetManagerServiceLPr(TypedXmlSerializer serializer) throws IOException {
         serializer.startTag(null, "keyset-settings");
         serializer.attribute(null, "version", Integer.toString(CURRENT_VERSION));
         writePublicKeysLPr(serializer);
@@ -685,7 +686,7 @@ public class KeySetManagerService {
         serializer.endTag(null, "keyset-settings");
     }
 
-    void writePublicKeysLPr(XmlSerializer serializer) throws IOException {
+    void writePublicKeysLPr(TypedXmlSerializer serializer) throws IOException {
         serializer.startTag(null, "keys");
         for (int pKeyIndex = 0; pKeyIndex < mPublicKeys.size(); pKeyIndex++) {
             long id = mPublicKeys.keyAt(pKeyIndex);
@@ -699,7 +700,7 @@ public class KeySetManagerService {
         serializer.endTag(null, "keys");
     }
 
-    void writeKeySetsLPr(XmlSerializer serializer) throws IOException {
+    void writeKeySetsLPr(TypedXmlSerializer serializer) throws IOException {
         serializer.startTag(null, "keysets");
         for (int keySetIndex = 0; keySetIndex < mKeySetMapping.size(); keySetIndex++) {
             long id = mKeySetMapping.keyAt(keySetIndex);
@@ -716,7 +717,7 @@ public class KeySetManagerService {
         serializer.endTag(null, "keysets");
     }
 
-    void readKeySetsLPw(XmlPullParser parser, ArrayMap<Long, Integer> keySetRefCounts)
+    void readKeySetsLPw(TypedXmlPullParser parser, ArrayMap<Long, Integer> keySetRefCounts)
             throws XmlPullParserException, IOException {
         int type;
         long currentKeySetId = 0;
@@ -757,7 +758,7 @@ public class KeySetManagerService {
         addRefCountsFromSavedPackagesLPw(keySetRefCounts);
     }
 
-    void readKeysLPw(XmlPullParser parser)
+    void readKeysLPw(TypedXmlPullParser parser)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -773,7 +774,7 @@ public class KeySetManagerService {
         }
     }
 
-    void readKeySetListLPw(XmlPullParser parser)
+    void readKeySetListLPw(TypedXmlPullParser parser)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -798,7 +799,7 @@ public class KeySetManagerService {
         }
     }
 
-    void readPublicKeyLPw(XmlPullParser parser)
+    void readPublicKeyLPw(TypedXmlPullParser parser)
             throws XmlPullParserException {
         String encodedID = parser.getAttributeValue(null, "identifier");
         long identifier = Long.parseLong(encodedID);
diff --git a/services/core/java/com/android/server/pm/PackageInstallerService.java b/services/core/java/com/android/server/pm/PackageInstallerService.java
index c282b9929349..34019c7ac15a 100644
--- a/services/core/java/com/android/server/pm/PackageInstallerService.java
+++ b/services/core/java/com/android/server/pm/PackageInstallerService.java
@@ -71,6 +71,8 @@ import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.R;
@@ -78,7 +80,6 @@ import com.android.internal.annotations.GuardedBy;
 import com.android.internal.content.PackageHelper;
 import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
 import com.android.internal.notification.SystemNotificationChannels;
-import com.android.internal.util.FastXmlSerializer;
 import com.android.internal.util.ImageUtils;
 import com.android.internal.util.IndentingPrintWriter;
 import com.android.server.IoThread;
@@ -91,9 +92,7 @@ import com.android.server.pm.permission.PermissionManagerServiceInternal;
 
 import libcore.io.IoUtils;
 
-import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
 import java.io.CharArrayWriter;
 import java.io.File;
@@ -102,7 +101,6 @@ import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FilenameFilter;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -383,8 +381,7 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements
         FileInputStream fis = null;
         try {
             fis = mSessionsFile.openRead();
-            final XmlPullParser in = Xml.newPullParser();
-            in.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser in = Xml.resolvePullParser(fis);
 
             int type;
             while ((type = in.next()) != END_DOCUMENT) {
@@ -467,8 +464,7 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements
         try {
             fos = mSessionsFile.startWrite();
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.startTag(null, TAG_SESSIONS);
             final int size = mSessions.size();
diff --git a/services/core/java/com/android/server/pm/PackageInstallerSession.java b/services/core/java/com/android/server/pm/PackageInstallerSession.java
index 57b80eab61e6..ab5b9d10b7a5 100644
--- a/services/core/java/com/android/server/pm/PackageInstallerSession.java
+++ b/services/core/java/com/android/server/pm/PackageInstallerSession.java
@@ -131,6 +131,8 @@ import android.util.ExceptionUtils;
 import android.util.MathUtils;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.apk.ApkSignatureVerifier;
 
 import com.android.internal.R;
@@ -3943,7 +3945,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
         }
     }
 
-    private static void writeGrantedRuntimePermissionsLocked(XmlSerializer out,
+    private static void writeGrantedRuntimePermissionsLocked(TypedXmlSerializer out,
             String[] grantedRuntimePermissions) throws IOException {
         if (grantedRuntimePermissions != null) {
             for (String permission : grantedRuntimePermissions) {
@@ -3954,7 +3956,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
         }
     }
 
-    private static void writeWhitelistedRestrictedPermissionsLocked(@NonNull XmlSerializer out,
+    private static void writeWhitelistedRestrictedPermissionsLocked(@NonNull TypedXmlSerializer out,
             @Nullable List<String> whitelistedRestrictedPermissions) throws IOException {
         if (whitelistedRestrictedPermissions != null) {
             final int permissionCount = whitelistedRestrictedPermissions.size();
@@ -3966,7 +3968,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
         }
     }
 
-    private static void writeAutoRevokePermissionsMode(@NonNull XmlSerializer out, int mode)
+    private static void writeAutoRevokePermissionsMode(@NonNull TypedXmlSerializer out, int mode)
             throws IOException {
         out.startTag(null, TAG_AUTO_REVOKE_PERMISSIONS_MODE);
         writeIntAttribute(out, ATTR_MODE, mode);
@@ -3979,12 +3981,12 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
     }
 
     /**
-     * Write this session to a {@link XmlSerializer}.
+     * Write this session to a {@link TypedXmlSerializer}.
      *
      * @param out Where to write the session to
      * @param sessionsDir The directory containing the sessions
      */
-    void write(@NonNull XmlSerializer out, @NonNull File sessionsDir) throws IOException {
+    void write(@NonNull TypedXmlSerializer out, @NonNull File sessionsDir) throws IOException {
         synchronized (mLock) {
             if (mDestroyed && !params.isStaged) {
                 return;
@@ -4127,7 +4129,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
     }
 
     /**
-     * Read new session from a {@link XmlPullParser xml description} and create it.
+     * Read new session from a {@link TypedXmlPullParser xml description} and create it.
      *
      * @param in The source of the description
      * @param callback Callback the session uses to notify about changes of it's state
@@ -4139,7 +4141,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub {
      * @param sessionProvider
      * @return The newly created session
      */
-    public static PackageInstallerSession readFromXml(@NonNull XmlPullParser in,
+    public static PackageInstallerSession readFromXml(@NonNull TypedXmlPullParser in,
             @NonNull PackageInstallerService.InternalCallback callback, @NonNull Context context,
             @NonNull PackageManagerService pm, Looper installerThread,
             @NonNull StagingManager stagingManager, @NonNull File sessionsDir,
diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index 05006168d66a..09cdef88d7f6 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -319,6 +319,8 @@ import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
 import android.util.TimingsTraceLog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.util.apk.ApkSignatureVerifier;
 import android.util.jar.StrictJarFile;
@@ -20682,7 +20684,7 @@ public class PackageManagerService extends IPackageManager.Stub
      * Common machinery for picking apart a restored XML blob and passing
      * it to a caller-supplied functor to be applied to the running system.
      */
-    private void restoreFromXml(XmlPullParser parser, int userId,
+    private void restoreFromXml(TypedXmlPullParser parser, int userId,
             String expectedStartTag, BlobXmlRestorer functor)
             throws IOException, XmlPullParserException {
         int type;
@@ -20710,7 +20712,8 @@ public class PackageManagerService extends IPackageManager.Stub
     }
 
     private interface BlobXmlRestorer {
-        void apply(XmlPullParser parser, int userId) throws IOException, XmlPullParserException;
+        void apply(TypedXmlPullParser parser, int userId)
+                throws IOException, XmlPullParserException;
     }
 
     /**
@@ -20726,7 +20729,7 @@ public class PackageManagerService extends IPackageManager.Stub
 
         ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
         try {
-            final XmlSerializer serializer = new FastXmlSerializer();
+            final TypedXmlSerializer serializer = Xml.newFastSerializer();
             serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
             serializer.startDocument(null, true);
             serializer.startTag(null, TAG_PREFERRED_BACKUP);
@@ -20755,7 +20758,7 @@ public class PackageManagerService extends IPackageManager.Stub
         }
 
         try {
-            final XmlPullParser parser = Xml.newPullParser();
+            final TypedXmlPullParser parser = Xml.newFastPullParser();
             parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
             restoreFromXml(parser, userId, TAG_PREFERRED_BACKUP,
                     (readParser, readUserId) -> {
@@ -20784,7 +20787,7 @@ public class PackageManagerService extends IPackageManager.Stub
 
         ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
         try {
-            final XmlSerializer serializer = new FastXmlSerializer();
+            final TypedXmlSerializer serializer = Xml.newFastSerializer();
             serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
             serializer.startDocument(null, true);
             serializer.startTag(null, TAG_DEFAULT_APPS);
@@ -20813,7 +20816,7 @@ public class PackageManagerService extends IPackageManager.Stub
         }
 
         try {
-            final XmlPullParser parser = Xml.newPullParser();
+            final TypedXmlPullParser parser = Xml.newFastPullParser();
             parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
             restoreFromXml(parser, userId, TAG_DEFAULT_APPS,
                     (parser1, userId1) -> {
@@ -20842,7 +20845,7 @@ public class PackageManagerService extends IPackageManager.Stub
 
         ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
         try {
-            final XmlSerializer serializer = new FastXmlSerializer();
+            final TypedXmlSerializer serializer = Xml.newFastSerializer();
             serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
             serializer.startDocument(null, true);
             serializer.startTag(null, TAG_INTENT_FILTER_VERIFICATION);
@@ -20871,7 +20874,7 @@ public class PackageManagerService extends IPackageManager.Stub
         }
 
         try {
-            final XmlPullParser parser = Xml.newPullParser();
+            final TypedXmlPullParser parser = Xml.newFastPullParser();
             parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
             restoreFromXml(parser, userId, TAG_INTENT_FILTER_VERIFICATION,
                     (parser1, userId1) -> {
@@ -22634,7 +22637,7 @@ public class PackageManagerService extends IPackageManager.Stub
                 pw.flush();
                 FileOutputStream fout = new FileOutputStream(fd);
                 BufferedOutputStream str = new BufferedOutputStream(fout);
-                XmlSerializer serializer = new FastXmlSerializer();
+                TypedXmlSerializer serializer = Xml.newFastSerializer();
                 try {
                     serializer.setOutput(str, StandardCharsets.UTF_8.name());
                     serializer.startDocument(null, true);
diff --git a/services/core/java/com/android/server/pm/PackageSignatures.java b/services/core/java/com/android/server/pm/PackageSignatures.java
index b7d1eec68c7a..e74792cfd4b7 100644
--- a/services/core/java/com/android/server/pm/PackageSignatures.java
+++ b/services/core/java/com/android/server/pm/PackageSignatures.java
@@ -21,6 +21,8 @@ import android.content.pm.PackageParser;
 import android.content.pm.PackageParser.SigningDetails.SignatureSchemeVersion;
 import android.content.pm.Signature;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.internal.util.XmlUtils;
 
@@ -52,7 +54,7 @@ class PackageSignatures {
         mSigningDetails = PackageParser.SigningDetails.UNKNOWN;
     }
 
-    void writeXml(XmlSerializer serializer, String tagName,
+    void writeXml(TypedXmlSerializer serializer, String tagName,
             ArrayList<Signature> writtenSignatures) throws IOException {
         if (mSigningDetails.signatures == null) {
             return;
@@ -75,8 +77,9 @@ class PackageSignatures {
         serializer.endTag(null, tagName);
     }
 
-    private void writeCertsListXml(XmlSerializer serializer, ArrayList<Signature> writtenSignatures,
-            Signature[] signatures, boolean isPastSigs) throws IOException {
+    private void writeCertsListXml(TypedXmlSerializer serializer,
+            ArrayList<Signature> writtenSignatures, Signature[] signatures, boolean isPastSigs)
+            throws IOException {
         for (int i=0; i<signatures.length; i++) {
             serializer.startTag(null, "cert");
             final Signature sig = signatures[i];
@@ -104,7 +107,7 @@ class PackageSignatures {
         }
     }
 
-    void readXml(XmlPullParser parser, ArrayList<Signature> readSignatures)
+    void readXml(TypedXmlPullParser parser, ArrayList<Signature> readSignatures)
             throws IOException, XmlPullParserException {
         PackageParser.SigningDetails.Builder builder =
                 new PackageParser.SigningDetails.Builder();
@@ -150,7 +153,7 @@ class PackageSignatures {
         }
     }
 
-    private int readCertsListXml(XmlPullParser parser, ArrayList<Signature> readSignatures,
+    private int readCertsListXml(TypedXmlPullParser parser, ArrayList<Signature> readSignatures,
             ArrayList<Signature> signatures, int count, boolean isPastSigs,
             PackageParser.SigningDetails.Builder builder)
             throws IOException, XmlPullParserException {
diff --git a/services/core/java/com/android/server/pm/PersistentPreferredActivity.java b/services/core/java/com/android/server/pm/PersistentPreferredActivity.java
index 5a6fd0923f53..6e6ab83e45d0 100644
--- a/services/core/java/com/android/server/pm/PersistentPreferredActivity.java
+++ b/services/core/java/com/android/server/pm/PersistentPreferredActivity.java
@@ -19,12 +19,13 @@ package com.android.server.pm;
 import android.content.ComponentName;
 import android.content.IntentFilter;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.internal.util.XmlUtils;
 
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
 import java.io.IOException;
 
@@ -46,7 +47,8 @@ class PersistentPreferredActivity extends IntentFilter {
         mIsSetByDpm = isSetByDpm;
     }
 
-    PersistentPreferredActivity(XmlPullParser parser) throws XmlPullParserException, IOException {
+    PersistentPreferredActivity(TypedXmlPullParser parser)
+            throws XmlPullParserException, IOException {
         String shortComponent = parser.getAttributeValue(null, ATTR_NAME);
         mComponent = ComponentName.unflattenFromString(shortComponent);
         if (mComponent == null) {
@@ -86,7 +88,7 @@ class PersistentPreferredActivity extends IntentFilter {
         }
     }
 
-    public void writeToXml(XmlSerializer serializer) throws IOException {
+    public void writeToXml(TypedXmlSerializer serializer) throws IOException {
         serializer.attribute(null, ATTR_NAME, mComponent.flattenToShortString());
         serializer.attribute(null, ATTR_SET_BY_DPM, Boolean.toString(mIsSetByDpm));
         serializer.startTag(null, ATTR_FILTER);
diff --git a/services/core/java/com/android/server/pm/PreferredActivity.java b/services/core/java/com/android/server/pm/PreferredActivity.java
index 89169264b0b6..4e1dcb27111d 100644
--- a/services/core/java/com/android/server/pm/PreferredActivity.java
+++ b/services/core/java/com/android/server/pm/PreferredActivity.java
@@ -16,15 +16,15 @@
 
 package com.android.server.pm;
 
-import com.android.internal.util.XmlUtils;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
-
 import android.content.ComponentName;
 import android.content.IntentFilter;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
+
+import com.android.internal.util.XmlUtils;
+
+import org.xmlpull.v1.XmlPullParserException;
 
 import java.io.IOException;
 
@@ -41,19 +41,19 @@ class PreferredActivity extends IntentFilter implements PreferredComponent.Callb
         mPref = new PreferredComponent(this, match, set, activity, always);
     }
 
-    PreferredActivity(XmlPullParser parser) throws XmlPullParserException, IOException {
+    PreferredActivity(TypedXmlPullParser parser) throws XmlPullParserException, IOException {
         mPref = new PreferredComponent(this, parser);
     }
 
-    public void writeToXml(XmlSerializer serializer, boolean full) throws IOException {
+    public void writeToXml(TypedXmlSerializer serializer, boolean full) throws IOException {
         mPref.writeToXml(serializer, full);
         serializer.startTag(null, "filter");
             super.writeToXml(serializer);
         serializer.endTag(null, "filter");
     }
 
-    public boolean onReadTag(String tagName, XmlPullParser parser) throws XmlPullParserException,
-            IOException {
+    public boolean onReadTag(String tagName, TypedXmlPullParser parser)
+            throws XmlPullParserException, IOException {
         if (tagName.equals("filter")) {
             if (DEBUG_FILTERS) {
                 Log.i(TAG, "Starting to parse filter...");
diff --git a/services/core/java/com/android/server/pm/PreferredComponent.java b/services/core/java/com/android/server/pm/PreferredComponent.java
index c312fc0eca2f..f743bbd14caf 100644
--- a/services/core/java/com/android/server/pm/PreferredComponent.java
+++ b/services/core/java/com/android/server/pm/PreferredComponent.java
@@ -29,6 +29,8 @@ import android.content.IntentFilter;
 import android.content.pm.ActivityInfo;
 import android.content.pm.ResolveInfo;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import java.io.IOException;
 import java.io.PrintWriter;
@@ -57,7 +59,7 @@ public class PreferredComponent {
     private final String mSetupWizardPackageName;
 
     public interface Callbacks {
-        public boolean onReadTag(String tagName, XmlPullParser parser)
+        public boolean onReadTag(String tagName, TypedXmlPullParser parser)
                 throws XmlPullParserException, IOException;
     }
 
@@ -97,7 +99,7 @@ public class PreferredComponent {
         }
     }
 
-    public PreferredComponent(Callbacks callbacks, XmlPullParser parser)
+    public PreferredComponent(Callbacks callbacks, TypedXmlPullParser parser)
             throws XmlPullParserException, IOException {
         mCallbacks = callbacks;
         mShortComponent = parser.getAttributeValue(null, ATTR_NAME);
@@ -182,7 +184,7 @@ public class PreferredComponent {
         return mParseError;
     }
 
-    public void writeToXml(XmlSerializer serializer, boolean full) throws IOException {
+    public void writeToXml(TypedXmlSerializer serializer, boolean full) throws IOException {
         final int NS = mSetClasses != null ? mSetClasses.length : 0;
         serializer.attribute(null, ATTR_NAME, mShortComponent);
         if (full) {
diff --git a/services/core/java/com/android/server/pm/RestrictionsSet.java b/services/core/java/com/android/server/pm/RestrictionsSet.java
index 5aff6bbe002e..4d74b08eb8b0 100644
--- a/services/core/java/com/android/server/pm/RestrictionsSet.java
+++ b/services/core/java/com/android/server/pm/RestrictionsSet.java
@@ -22,12 +22,13 @@ import android.annotation.UserIdInt;
 import android.os.Bundle;
 import android.os.UserManager;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.internal.annotations.VisibleForTesting;
 
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
 import java.io.IOException;
 import java.io.PrintWriter;
@@ -183,7 +184,7 @@ public class RestrictionsSet {
     /**
      * Serialize a given {@link RestrictionsSet} to XML.
      */
-    public void writeRestrictions(@NonNull XmlSerializer serializer, @NonNull String outerTag)
+    public void writeRestrictions(@NonNull TypedXmlSerializer serializer, @NonNull String outerTag)
             throws IOException {
         serializer.startTag(null, outerTag);
         for (int i = 0; i < mUserRestrictions.size(); i++) {
@@ -199,7 +200,7 @@ public class RestrictionsSet {
     /**
      * Read restrictions from XML.
      */
-    public static RestrictionsSet readRestrictions(@NonNull XmlPullParser parser,
+    public static RestrictionsSet readRestrictions(@NonNull TypedXmlPullParser parser,
             @NonNull String outerTag) throws IOException, XmlPullParserException {
         RestrictionsSet restrictionsSet = new RestrictionsSet();
         int userId = 0;
diff --git a/services/core/java/com/android/server/pm/Settings.java b/services/core/java/com/android/server/pm/Settings.java
index 71e7358701fd..35fa7fc8ee56 100644
--- a/services/core/java/com/android/server/pm/Settings.java
+++ b/services/core/java/com/android/server/pm/Settings.java
@@ -74,6 +74,7 @@ import android.os.Trace;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.os.storage.StorageManager;
+import android.os.storage.VolumeInfo;
 import android.service.pm.PackageServiceDumpProto;
 import android.text.TextUtils;
 import android.util.ArrayMap;
@@ -88,6 +89,8 @@ import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
 import android.util.SparseLongArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.util.proto.ProtoOutputStream;
 
@@ -96,13 +99,13 @@ import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.os.BackgroundThread;
 import com.android.internal.util.ArrayUtils;
 import com.android.internal.util.CollectionUtils;
-import com.android.internal.util.FastXmlSerializer;
 import com.android.internal.util.IndentingPrintWriter;
 import com.android.internal.util.JournaledFile;
 import com.android.internal.util.XmlUtils;
 import com.android.permission.persistence.RuntimePermissionsPersistence;
 import com.android.permission.persistence.RuntimePermissionsState;
 import com.android.server.LocalServices;
+import com.android.server.backup.PreferredActivityBackupHelper;
 import com.android.server.pm.Installer.InstallerException;
 import com.android.server.pm.parsing.PackageInfoUtils;
 import com.android.server.pm.parsing.pkg.AndroidPackage;
@@ -117,10 +120,7 @@ import libcore.io.IoUtils;
 
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
@@ -1297,7 +1297,7 @@ public final class Settings {
      *
      * @see PreferredActivityBackupHelper
      */
-    void readPreferredActivitiesLPw(XmlPullParser parser, int userId)
+    void readPreferredActivitiesLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1330,7 +1330,7 @@ public final class Settings {
         }
     }
 
-    private void readPersistentPreferredActivitiesLPw(XmlPullParser parser, int userId)
+    private void readPersistentPreferredActivitiesLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1352,7 +1352,7 @@ public final class Settings {
         }
     }
 
-    private void readCrossProfileIntentFiltersLPw(XmlPullParser parser, int userId)
+    private void readCrossProfileIntentFiltersLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1374,8 +1374,8 @@ public final class Settings {
         }
     }
 
-    private void readDomainVerificationLPw(XmlPullParser parser, PackageSettingBase packageSetting)
-            throws XmlPullParserException, IOException {
+    private void readDomainVerificationLPw(TypedXmlPullParser parser,
+            PackageSettingBase packageSetting) throws XmlPullParserException, IOException {
         IntentFilterVerificationInfo ivi = new IntentFilterVerificationInfo(parser);
         packageSetting.setIntentFilterVerificationInfo(ivi);
         if (DEBUG_PARSER) {
@@ -1383,7 +1383,7 @@ public final class Settings {
         }
     }
 
-    private void readRestoredIntentFilterVerifications(XmlPullParser parser)
+    private void readRestoredIntentFilterVerifications(TypedXmlPullParser parser)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1407,7 +1407,7 @@ public final class Settings {
         }
     }
 
-    void readDefaultAppsLPw(XmlPullParser parser, int userId)
+    void readDefaultAppsLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1431,7 +1431,7 @@ public final class Settings {
         }
     }
 
-    void readBlockUninstallPackagesLPw(XmlPullParser parser, int userId)
+    void readBlockUninstallPackagesLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         int outerDepth = parser.getDepth();
         int type;
@@ -1521,8 +1521,7 @@ public final class Settings {
                 str = new FileInputStream(userPackagesStateFile);
                 if (DEBUG_MU) Log.i(TAG, "Reading " + userPackagesStateFile);
             }
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(str, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(str);
 
             int type;
             while ((type=parser.next()) != XmlPullParser.START_TAG
@@ -1752,7 +1751,7 @@ public final class Settings {
         return packages.contains(packageName);
     }
 
-    private ArraySet<String> readComponentsLPr(XmlPullParser parser)
+    private ArraySet<String> readComponentsLPr(TypedXmlPullParser parser)
             throws IOException, XmlPullParserException {
         ArraySet<String> components = null;
         int type;
@@ -1784,7 +1783,7 @@ public final class Settings {
      * for recording packages.xml internally and for supporting backup/restore of the
      * preferred activity configuration.
      */
-    void writePreferredActivitiesLPr(XmlSerializer serializer, int userId, boolean full)
+    void writePreferredActivitiesLPr(TypedXmlSerializer serializer, int userId, boolean full)
             throws IllegalArgumentException, IllegalStateException, IOException {
         serializer.startTag(null, "preferred-activities");
         PreferredIntentResolver pir = mPreferredActivities.get(userId);
@@ -1798,7 +1797,7 @@ public final class Settings {
         serializer.endTag(null, "preferred-activities");
     }
 
-    void writePersistentPreferredActivitiesLPr(XmlSerializer serializer, int userId)
+    void writePersistentPreferredActivitiesLPr(TypedXmlSerializer serializer, int userId)
             throws IllegalArgumentException, IllegalStateException, IOException {
         serializer.startTag(null, TAG_PERSISTENT_PREFERRED_ACTIVITIES);
         PersistentPreferredIntentResolver ppir = mPersistentPreferredActivities.get(userId);
@@ -1812,7 +1811,7 @@ public final class Settings {
         serializer.endTag(null, TAG_PERSISTENT_PREFERRED_ACTIVITIES);
     }
 
-    void writeCrossProfileIntentFiltersLPr(XmlSerializer serializer, int userId)
+    void writeCrossProfileIntentFiltersLPr(TypedXmlSerializer serializer, int userId)
             throws IllegalArgumentException, IllegalStateException, IOException {
         serializer.startTag(null, TAG_CROSS_PROFILE_INTENT_FILTERS);
         CrossProfileIntentResolver cpir = mCrossProfileIntentResolvers.get(userId);
@@ -1826,7 +1825,7 @@ public final class Settings {
         serializer.endTag(null, TAG_CROSS_PROFILE_INTENT_FILTERS);
     }
 
-    void writeDomainVerificationsLPr(XmlSerializer serializer,
+    void writeDomainVerificationsLPr(TypedXmlSerializer serializer,
                                      IntentFilterVerificationInfo verificationInfo)
             throws IllegalArgumentException, IllegalStateException, IOException {
         if (verificationInfo != null && verificationInfo.getPackageName() != null) {
@@ -1841,7 +1840,7 @@ public final class Settings {
     }
 
     // Specifically for backup/restore
-    void writeAllDomainVerificationsLPr(XmlSerializer serializer, int userId)
+    void writeAllDomainVerificationsLPr(TypedXmlSerializer serializer, int userId)
             throws IllegalArgumentException, IllegalStateException, IOException {
         serializer.startTag(null, TAG_ALL_INTENT_FILTER_VERIFICATION);
         final int N = mPackages.size();
@@ -1856,7 +1855,7 @@ public final class Settings {
     }
 
     // Specifically for backup/restore
-    void readAllDomainVerificationsLPr(XmlPullParser parser, int userId)
+    void readAllDomainVerificationsLPr(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         mRestoredIntentFilterVerifications.clear();
 
@@ -1896,7 +1895,7 @@ public final class Settings {
         }
     }
 
-    void writeDefaultAppsLPr(XmlSerializer serializer, int userId)
+    void writeDefaultAppsLPr(TypedXmlSerializer serializer, int userId)
             throws IllegalArgumentException, IllegalStateException, IOException {
         serializer.startTag(null, TAG_DEFAULT_APPS);
         String defaultBrowser = mDefaultBrowserApp.get(userId);
@@ -1908,7 +1907,7 @@ public final class Settings {
         serializer.endTag(null, TAG_DEFAULT_APPS);
     }
 
-    void writeBlockUninstallPackagesLPr(XmlSerializer serializer, int userId)
+    void writeBlockUninstallPackagesLPr(TypedXmlSerializer serializer, int userId)
             throws IOException  {
         ArraySet<String> packages = mBlockUninstallPackages.get(userId);
         if (packages != null) {
@@ -1955,10 +1954,7 @@ public final class Settings {
 
         try {
             final FileOutputStream fstr = new FileOutputStream(userPackagesStateFile);
-            final BufferedOutputStream str = new BufferedOutputStream(fstr);
-
-            final XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(str, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(fstr);
             serializer.startDocument(null, true);
             serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -2076,9 +2072,9 @@ public final class Settings {
 
             serializer.endDocument();
 
-            str.flush();
+            fstr.flush();
             FileUtils.sync(fstr);
-            str.close();
+            fstr.close();
 
             // New settings successfully written, old ones are no longer
             // needed.
@@ -2108,7 +2104,7 @@ public final class Settings {
         }
     }
 
-    void readInstallPermissionsLPr(XmlPullParser parser,
+    void readInstallPermissionsLPr(TypedXmlPullParser parser,
             LegacyPermissionState permissionsState) throws IOException, XmlPullParserException {
         int outerDepth = parser.getDepth();
         int type;
@@ -2138,7 +2134,7 @@ public final class Settings {
         }
     }
 
-    void writePermissionsLPr(XmlSerializer serializer, Collection<PermissionState> permissionStates)
+    void writePermissionsLPr(TypedXmlSerializer serializer, Collection<PermissionState> permissionStates)
             throws IOException {
         if (permissionStates.isEmpty()) {
             return;
@@ -2157,7 +2153,7 @@ public final class Settings {
         serializer.endTag(null, TAG_PERMISSIONS);
     }
 
-    void readUsesStaticLibLPw(XmlPullParser parser, PackageSetting outPs)
+    void readUsesStaticLibLPw(TypedXmlPullParser parser, PackageSetting outPs)
             throws IOException, XmlPullParserException {
         String libName = parser.getAttributeValue(null, ATTR_NAME);
         String libVersionStr = parser.getAttributeValue(null, ATTR_VERSION);
@@ -2179,7 +2175,7 @@ public final class Settings {
         XmlUtils.skipCurrentTag(parser);
     }
 
-    void writeUsesStaticLibLPw(XmlSerializer serializer, String[] usesStaticLibraries,
+    void writeUsesStaticLibLPw(TypedXmlSerializer serializer, String[] usesStaticLibraries,
             long[] usesStaticLibraryVersions) throws IOException {
         if (ArrayUtils.isEmpty(usesStaticLibraries) || ArrayUtils.isEmpty(usesStaticLibraryVersions)
                 || usesStaticLibraries.length != usesStaticLibraryVersions.length) {
@@ -2236,8 +2232,7 @@ public final class Settings {
                 }
                 str = new FileInputStream(mStoppedPackagesFilename);
             }
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(str, null);
+            final TypedXmlPullParser parser = Xml.resolvePullParser(str);
 
             int type;
             while ((type=parser.next()) != XmlPullParser.START_TAG
@@ -2334,12 +2329,8 @@ public final class Settings {
         mPastSignatures.clear();
 
         try {
-            FileOutputStream fstr = new FileOutputStream(mSettingsFilename);
-            BufferedOutputStream str = new BufferedOutputStream(fstr);
-
-            //XmlSerializer serializer = XmlUtils.serializerInstance();
-            XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(str, StandardCharsets.UTF_8.name());
+            final FileOutputStream fstr = new FileOutputStream(mSettingsFilename);
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(fstr);
             serializer.startDocument(null, true);
             serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -2429,9 +2420,9 @@ public final class Settings {
 
             serializer.endDocument();
 
-            str.flush();
+            fstr.flush();
             FileUtils.sync(fstr);
-            str.close();
+            fstr.close();
 
             // New settings successfully written, old ones are no longer
             // needed.
@@ -2685,7 +2676,7 @@ public final class Settings {
         }
     }
 
-    void writeDisabledSysPackageLPr(XmlSerializer serializer, final PackageSetting pkg)
+    void writeDisabledSysPackageLPr(TypedXmlSerializer serializer, final PackageSetting pkg)
             throws java.io.IOException {
         serializer.startTag(null, "updated-package");
         serializer.attribute(null, ATTR_NAME, pkg.name);
@@ -2727,7 +2718,7 @@ public final class Settings {
         serializer.endTag(null, "updated-package");
     }
 
-    void writePackageLPr(XmlSerializer serializer, final PackageSetting pkg)
+    void writePackageLPr(TypedXmlSerializer serializer, final PackageSetting pkg)
             throws java.io.IOException {
         serializer.startTag(null, "package");
         serializer.attribute(null, ATTR_NAME, pkg.name);
@@ -2823,7 +2814,7 @@ public final class Settings {
         serializer.endTag(null, "package");
     }
 
-    void writeSigningKeySetLPr(XmlSerializer serializer,
+    void writeSigningKeySetLPr(TypedXmlSerializer serializer,
             PackageKeySetData data) throws IOException {
         serializer.startTag(null, "proper-signing-keyset");
         serializer.attribute(null, "identifier",
@@ -2831,7 +2822,7 @@ public final class Settings {
         serializer.endTag(null, "proper-signing-keyset");
     }
 
-    void writeUpgradeKeySetsLPr(XmlSerializer serializer,
+    void writeUpgradeKeySetsLPr(TypedXmlSerializer serializer,
             PackageKeySetData data) throws IOException {
         if (data.isUsingUpgradeKeySets()) {
             for (long id : data.getUpgradeKeySets()) {
@@ -2842,7 +2833,7 @@ public final class Settings {
         }
     }
 
-    void writeKeySetAliasesLPr(XmlSerializer serializer,
+    void writeKeySetAliasesLPr(TypedXmlSerializer serializer,
             PackageKeySetData data) throws IOException {
         for (Map.Entry<String, Long> e: data.getAliases().entrySet()) {
             serializer.startTag(null, "defined-keyset");
@@ -2892,8 +2883,7 @@ public final class Settings {
                 }
                 str = new FileInputStream(mSettingsFilename);
             }
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(str, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(str);
 
             int type;
             while ((type = parser.next()) != XmlPullParser.START_TAG
@@ -3147,9 +3137,8 @@ public final class Settings {
                     Log.d(TAG, "Reading default preferred " + f);
                 }
 
-                try (InputStream str = new BufferedInputStream(new FileInputStream(f))) {
-                    XmlPullParser parser = Xml.newPullParser();
-                    parser.setInput(str, null);
+                try (InputStream str = new FileInputStream(f)) {
+                    final TypedXmlPullParser parser = Xml.resolvePullParser(str);
 
                     int type;
                     while ((type = parser.next()) != XmlPullParser.START_TAG
@@ -3420,7 +3409,7 @@ public final class Settings {
         }
     }
 
-    private void readDefaultPreferredActivitiesLPw(XmlPullParser parser, int userId)
+    private void readDefaultPreferredActivitiesLPw(TypedXmlPullParser parser, int userId)
             throws XmlPullParserException, IOException {
         final PackageManagerInternal pmInternal =
                 LocalServices.getService(PackageManagerInternal.class);
@@ -3452,8 +3441,8 @@ public final class Settings {
         }
     }
 
-    private void readDisabledSysPackageLPw(XmlPullParser parser) throws XmlPullParserException,
-            IOException {
+    private void readDisabledSysPackageLPw(TypedXmlPullParser parser)
+            throws XmlPullParserException, IOException {
         String name = parser.getAttributeValue(null, ATTR_NAME);
         String realName = parser.getAttributeValue(null, "realName");
         String codePathStr = parser.getAttributeValue(null, "codePath");
@@ -3551,7 +3540,8 @@ public final class Settings {
     private static int PRE_M_APP_INFO_FLAG_CANT_SAVE_STATE = 1<<28;
     private static int PRE_M_APP_INFO_FLAG_PRIVILEGED = 1<<30;
 
-    private void readPackageLPw(XmlPullParser parser) throws XmlPullParserException, IOException {
+    private void readPackageLPw(TypedXmlPullParser parser)
+            throws XmlPullParserException, IOException {
         String name = null;
         String realName = null;
         String idStr = null;
@@ -3891,7 +3881,7 @@ public final class Settings {
         }
     }
 
-    private Map<String, ArraySet<String>> readMimeGroupLPw(XmlPullParser parser,
+    private Map<String, ArraySet<String>> readMimeGroupLPw(TypedXmlPullParser parser,
             Map<String, ArraySet<String>> mimeGroups) throws XmlPullParserException, IOException {
         String groupName = parser.getAttributeValue(null, ATTR_NAME);
         if (groupName == null) {
@@ -3932,7 +3922,7 @@ public final class Settings {
         return mimeGroups;
     }
 
-    private void writeMimeGroupLPr(XmlSerializer serializer,
+    private void writeMimeGroupLPr(TypedXmlSerializer serializer,
             Map<String, ArraySet<String>> mimeGroups) throws IOException {
         if (mimeGroups == null) {
             return;
@@ -3952,8 +3942,8 @@ public final class Settings {
         }
     }
 
-    private void readDisabledComponentsLPw(PackageSettingBase packageSetting, XmlPullParser parser,
-            int userId) throws IOException, XmlPullParserException {
+    private void readDisabledComponentsLPw(PackageSettingBase packageSetting,
+            TypedXmlPullParser parser, int userId) throws IOException, XmlPullParserException {
         int outerDepth = parser.getDepth();
         int type;
         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
@@ -3980,8 +3970,8 @@ public final class Settings {
         }
     }
 
-    private void readEnabledComponentsLPw(PackageSettingBase packageSetting, XmlPullParser parser,
-            int userId) throws IOException, XmlPullParserException {
+    private void readEnabledComponentsLPw(PackageSettingBase packageSetting,
+            TypedXmlPullParser parser, int userId) throws IOException, XmlPullParserException {
         int outerDepth = parser.getDepth();
         int type;
         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
@@ -4008,7 +3998,8 @@ public final class Settings {
         }
     }
 
-    private void readSharedUserLPw(XmlPullParser parser) throws XmlPullParserException,IOException {
+    private void readSharedUserLPw(TypedXmlPullParser parser)
+            throws XmlPullParserException, IOException {
         String name = null;
         String idStr = null;
         int pkgFlags = 0;
@@ -5547,8 +5538,7 @@ public final class Settings {
             }
 
             try {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(in, null);
+                final TypedXmlPullParser parser = Xml.resolvePullParser(in);
                 parseRuntimePermissionsLPr(parser, userId);
 
             } catch (XmlPullParserException | IOException e) {
@@ -5562,7 +5552,7 @@ public final class Settings {
         // Private internals
 
         @GuardedBy("Settings.this.mLock")
-        private void parseRuntimePermissionsLPr(XmlPullParser parser, int userId)
+        private void parseRuntimePermissionsLPr(TypedXmlPullParser parser, int userId)
                 throws IOException, XmlPullParserException {
             final int outerDepth = parser.getDepth();
             int type;
@@ -5608,7 +5598,7 @@ public final class Settings {
             }
         }
 
-        private void parsePermissionsLPr(XmlPullParser parser,
+        private void parsePermissionsLPr(TypedXmlPullParser parser,
                 LegacyPermissionState permissionsState, int userId)
                 throws IOException, XmlPullParserException {
             final int outerDepth = parser.getDepth();
diff --git a/services/core/java/com/android/server/pm/UserManagerService.java b/services/core/java/com/android/server/pm/UserManagerService.java
index 24082b86132c..3b91d6ac5bee 100644
--- a/services/core/java/com/android/server/pm/UserManagerService.java
+++ b/services/core/java/com/android/server/pm/UserManagerService.java
@@ -94,6 +94,8 @@ import android.util.SparseArray;
 import android.util.SparseBooleanArray;
 import android.util.SparseIntArray;
 import android.util.TimeUtils;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -102,7 +104,6 @@ import com.android.internal.app.IAppOpsService;
 import com.android.internal.logging.MetricsLogger;
 import com.android.internal.os.BackgroundThread;
 import com.android.internal.util.DumpUtils;
-import com.android.internal.util.FastXmlSerializer;
 import com.android.internal.util.FrameworkStatsLog;
 import com.android.internal.util.Preconditions;
 import com.android.internal.util.XmlUtils;
@@ -121,7 +122,6 @@ import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 import org.xmlpull.v1.XmlSerializer;
 
-import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
@@ -131,7 +131,6 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -2548,8 +2547,7 @@ public class UserManagerService extends IUserManager.Stub {
         AtomicFile userListFile = new AtomicFile(mUserListFile);
         try {
             fis = userListFile.openRead();
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             int type;
             while ((type = parser.next()) != XmlPullParser.START_TAG
                     && type != XmlPullParser.END_DOCUMENT) {
@@ -2874,8 +2872,7 @@ public class UserManagerService extends IUserManager.Stub {
         AtomicFile userFile = new AtomicFile(new File(mUsersDir, userData.info.id + XML_SUFFIX));
         try {
             fos = userFile.startWrite();
-            final BufferedOutputStream bos = new BufferedOutputStream(fos);
-            writeUserLP(userData, bos);
+            writeUserLP(userData, fos);
             userFile.finishWrite(fos);
         } catch (Exception ioe) {
             Slog.e(LOG_TAG, "Error writing user info " + userData.info.id, ioe);
@@ -2893,9 +2890,7 @@ public class UserManagerService extends IUserManager.Stub {
     @VisibleForTesting
     void writeUserLP(UserData userData, OutputStream os)
             throws IOException, XmlPullParserException {
-        // XmlSerializer serializer = XmlUtils.serializerInstance();
-        final XmlSerializer serializer = new FastXmlSerializer();
-        serializer.setOutput(os, StandardCharsets.UTF_8.name());
+        final TypedXmlSerializer serializer = Xml.resolveSerializer(os);
         serializer.startDocument(null, true);
         serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -3001,11 +2996,7 @@ public class UserManagerService extends IUserManager.Stub {
         AtomicFile userListFile = new AtomicFile(mUserListFile);
         try {
             fos = userListFile.startWrite();
-            final BufferedOutputStream bos = new BufferedOutputStream(fos);
-
-            // XmlSerializer serializer = XmlUtils.serializerInstance();
-            final XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(bos, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(fos);
             serializer.startDocument(null, true);
             serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -3092,8 +3083,7 @@ public class UserManagerService extends IUserManager.Stub {
         RestrictionsSet localRestrictions = null;
         Bundle globalRestrictions = null;
 
-        XmlPullParser parser = Xml.newPullParser();
-        parser.setInput(is, StandardCharsets.UTF_8.name());
+        final TypedXmlPullParser parser = Xml.resolvePullParser(is);
         int type;
         while ((type = parser.next()) != XmlPullParser.START_TAG
                 && type != XmlPullParser.END_DOCUMENT) {
@@ -3231,7 +3221,7 @@ public class UserManagerService extends IUserManager.Stub {
         return userData;
     }
 
-    private int readIntAttribute(XmlPullParser parser, String attr, int defaultValue) {
+    private int readIntAttribute(TypedXmlPullParser parser, String attr, int defaultValue) {
         String valueString = parser.getAttributeValue(null, attr);
         if (valueString == null) return defaultValue;
         try {
@@ -3241,7 +3231,7 @@ public class UserManagerService extends IUserManager.Stub {
         }
     }
 
-    private long readLongAttribute(XmlPullParser parser, String attr, long defaultValue) {
+    private long readLongAttribute(TypedXmlPullParser parser, String attr, long defaultValue) {
         String valueString = parser.getAttributeValue(null, attr);
         if (valueString == null) return defaultValue;
         try {
@@ -4259,8 +4249,7 @@ public class UserManagerService extends IUserManager.Stub {
         FileInputStream fis = null;
         try {
             fis = restrictionsFile.openRead();
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             XmlUtils.nextElement(parser);
             if (parser.getEventType() != XmlPullParser.START_TAG) {
                 Slog.e(LOG_TAG, "Unable to read restrictions file "
@@ -4279,7 +4268,7 @@ public class UserManagerService extends IUserManager.Stub {
     }
 
     private static void readEntry(Bundle restrictions, ArrayList<String> values,
-            XmlPullParser parser) throws XmlPullParserException, IOException {
+            TypedXmlPullParser parser) throws XmlPullParserException, IOException {
         int type = parser.getEventType();
         if (type == XmlPullParser.START_TAG && parser.getName().equals(TAG_ENTRY)) {
             String key = parser.getAttributeValue(null, ATTR_KEY);
@@ -4322,7 +4311,7 @@ public class UserManagerService extends IUserManager.Stub {
         }
     }
 
-    private static Bundle readBundleEntry(XmlPullParser parser, ArrayList<String> values)
+    private static Bundle readBundleEntry(TypedXmlPullParser parser, ArrayList<String> values)
             throws IOException, XmlPullParserException {
         Bundle childBundle = new Bundle();
         final int outerDepth = parser.getDepth();
@@ -4347,10 +4336,7 @@ public class UserManagerService extends IUserManager.Stub {
         FileOutputStream fos = null;
         try {
             fos = restrictionsFile.startWrite();
-            final BufferedOutputStream bos = new BufferedOutputStream(fos);
-
-            final XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(bos, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(fos);
             serializer.startDocument(null, true);
             serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
 
@@ -4366,7 +4352,7 @@ public class UserManagerService extends IUserManager.Stub {
         }
     }
 
-    private static void writeBundle(Bundle restrictions, XmlSerializer serializer)
+    private static void writeBundle(Bundle restrictions, TypedXmlSerializer serializer)
             throws IOException {
         for (String key : restrictions.keySet()) {
             Object value = restrictions.get(key);
diff --git a/services/core/java/com/android/server/pm/UserRestrictionsUtils.java b/services/core/java/com/android/server/pm/UserRestrictionsUtils.java
index 87a883c92761..145dd24e2998 100644
--- a/services/core/java/com/android/server/pm/UserRestrictionsUtils.java
+++ b/services/core/java/com/android/server/pm/UserRestrictionsUtils.java
@@ -41,8 +41,11 @@ import android.telephony.SubscriptionManager;
 import android.util.Log;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.internal.util.Preconditions;
+import com.android.internal.util.XmlUtils;
 import com.android.server.LocalServices;
 
 import com.google.android.collect.Sets;
@@ -327,6 +330,11 @@ public class UserRestrictionsUtils {
 
     public static void writeRestrictions(@NonNull XmlSerializer serializer,
             @Nullable Bundle restrictions, @NonNull String tag) throws IOException {
+        writeRestrictions(XmlUtils.makeTyped(serializer), restrictions, tag);
+    }
+
+    public static void writeRestrictions(@NonNull TypedXmlSerializer serializer,
+            @Nullable Bundle restrictions, @NonNull String tag) throws IOException {
         if (restrictions == null) {
             return;
         }
@@ -348,6 +356,10 @@ public class UserRestrictionsUtils {
     }
 
     public static void readRestrictions(XmlPullParser parser, Bundle restrictions) {
+        readRestrictions(XmlUtils.makeTyped(parser), restrictions);
+    }
+
+    public static void readRestrictions(TypedXmlPullParser parser, Bundle restrictions) {
         restrictions.clear();
         for (String key : USER_RESTRICTIONS) {
             final String value = parser.getAttributeValue(null, key);
@@ -358,6 +370,10 @@ public class UserRestrictionsUtils {
     }
 
     public static Bundle readRestrictions(XmlPullParser parser) {
+        return readRestrictions(XmlUtils.makeTyped(parser));
+    }
+
+    public static Bundle readRestrictions(TypedXmlPullParser parser) {
         final Bundle result = new Bundle();
         readRestrictions(parser, result);
         return result;
diff --git a/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java b/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java
index 7a37bdda5fab..8940256a9ff7 100644
--- a/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java
+++ b/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java
@@ -60,6 +60,7 @@ import android.util.ArraySet;
 import android.util.Log;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
 import android.util.Xml;
 
 import com.android.internal.util.ArrayUtils;
@@ -1410,7 +1411,7 @@ public final class DefaultPermissionGrantPolicy {
             try (
                 InputStream str = new BufferedInputStream(new FileInputStream(file))
             ) {
-                XmlPullParser parser = Xml.newPullParser();
+                TypedXmlPullParser parser = Xml.newFastPullParser();
                 parser.setInput(str, null);
                 parse(pm, parser, grantExceptions);
             } catch (XmlPullParserException | IOException e) {
@@ -1421,7 +1422,7 @@ public final class DefaultPermissionGrantPolicy {
         return grantExceptions;
     }
 
-    private void parse(PackageManagerWrapper pm, XmlPullParser parser,
+    private void parse(PackageManagerWrapper pm, TypedXmlPullParser parser,
             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
             throws IOException, XmlPullParserException {
         final int outerDepth = parser.getDepth();
@@ -1439,7 +1440,7 @@ public final class DefaultPermissionGrantPolicy {
         }
     }
 
-    private void parseExceptions(PackageManagerWrapper pm, XmlPullParser parser,
+    private void parseExceptions(PackageManagerWrapper pm, TypedXmlPullParser parser,
             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
             throws IOException, XmlPullParserException {
         final int outerDepth = parser.getDepth();
@@ -1488,7 +1489,7 @@ public final class DefaultPermissionGrantPolicy {
         }
     }
 
-    private void parsePermission(XmlPullParser parser, List<DefaultPermissionGrant>
+    private void parsePermission(TypedXmlPullParser parser, List<DefaultPermissionGrant>
             outPackageExceptions) throws IOException, XmlPullParserException {
         final int outerDepth = parser.getDepth();
         int type;
diff --git a/services/core/java/com/android/server/pm/permission/LegacyPermission.java b/services/core/java/com/android/server/pm/permission/LegacyPermission.java
index a19a05ae021c..48243a4bfa48 100644
--- a/services/core/java/com/android/server/pm/permission/LegacyPermission.java
+++ b/services/core/java/com/android/server/pm/permission/LegacyPermission.java
@@ -21,15 +21,14 @@ import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.content.pm.PermissionInfo;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.server.pm.DumpState;
 import com.android.server.pm.PackageManagerService;
 
 import libcore.util.EmptyArray;
 
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlSerializer;
-
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.lang.annotation.Retention;
@@ -133,7 +132,7 @@ public final class LegacyPermission {
      * @hide
      */
     public static boolean read(@NonNull Map<String, LegacyPermission> out,
-            @NonNull XmlPullParser parser) {
+            @NonNull TypedXmlPullParser parser) {
         final String tagName = parser.getName();
         if (!tagName.equals(TAG_ITEM)) {
             return false;
@@ -166,7 +165,7 @@ public final class LegacyPermission {
         return true;
     }
 
-    private static int readInt(@NonNull XmlPullParser parser, @Nullable String namespace,
+    private static int readInt(@NonNull TypedXmlPullParser parser, @Nullable String namespace,
             @NonNull String name, int defaultValue) {
         final String value = parser.getAttributeValue(namespace, name);
         if (value == null) {
@@ -186,7 +185,7 @@ public final class LegacyPermission {
     /**
      * @hide
      */
-    public void write(@NonNull XmlSerializer serializer) throws IOException {
+    public void write(@NonNull TypedXmlSerializer serializer) throws IOException {
         if (mPermissionInfo.packageName == null) {
             return;
         }
diff --git a/services/core/java/com/android/server/pm/permission/LegacyPermissionSettings.java b/services/core/java/com/android/server/pm/permission/LegacyPermissionSettings.java
index cc0b79872ba0..f63600a188cb 100644
--- a/services/core/java/com/android/server/pm/permission/LegacyPermissionSettings.java
+++ b/services/core/java/com/android/server/pm/permission/LegacyPermissionSettings.java
@@ -21,6 +21,8 @@ import android.annotation.Nullable;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Log;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 
 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.util.XmlUtils;
@@ -99,14 +101,14 @@ public class LegacyPermissionSettings {
         }
     }
 
-    public void readPermissions(@NonNull XmlPullParser parser) throws IOException,
+    public void readPermissions(@NonNull TypedXmlPullParser parser) throws IOException,
             XmlPullParserException {
         synchronized (mLock) {
             readPermissions(mPermissions, parser);
         }
     }
 
-    public void readPermissionTrees(@NonNull XmlPullParser parser) throws IOException,
+    public void readPermissionTrees(@NonNull TypedXmlPullParser parser) throws IOException,
             XmlPullParserException {
         synchronized (mLock) {
             readPermissions(mPermissionTrees, parser);
@@ -114,7 +116,7 @@ public class LegacyPermissionSettings {
     }
 
     public static void readPermissions(@NonNull ArrayMap<String, LegacyPermission> out,
-            @NonNull XmlPullParser parser) throws IOException, XmlPullParserException {
+            @NonNull TypedXmlPullParser parser) throws IOException, XmlPullParserException {
         int outerDepth = parser.getDepth();
         int type;
         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
@@ -132,7 +134,7 @@ public class LegacyPermissionSettings {
         }
     }
 
-    public void writePermissions(@NonNull XmlSerializer serializer) throws IOException {
+    public void writePermissions(@NonNull TypedXmlSerializer serializer) throws IOException {
         synchronized (mLock) {
             for (LegacyPermission bp : mPermissions.values()) {
                 bp.write(serializer);
@@ -140,7 +142,7 @@ public class LegacyPermissionSettings {
         }
     }
 
-    public void writePermissionTrees(@NonNull XmlSerializer serializer) throws IOException {
+    public void writePermissionTrees(@NonNull TypedXmlSerializer serializer) throws IOException {
         synchronized (mLock) {
             for (LegacyPermission bp : mPermissionTrees.values()) {
                 bp.write(serializer);
diff --git a/services/core/java/com/android/server/power/batterysaver/FileUpdater.java b/services/core/java/com/android/server/power/batterysaver/FileUpdater.java
index c08b610ccd2d..1387617ab39c 100644
--- a/services/core/java/com/android/server/power/batterysaver/FileUpdater.java
+++ b/services/core/java/com/android/server/power/batterysaver/FileUpdater.java
@@ -23,6 +23,8 @@ import android.os.SystemProperties;
 import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -316,8 +318,7 @@ public class FileUpdater {
             outs = file.startWrite();
 
             // Write to XML
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(outs, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(outs);
             out.startDocument(null, true);
             out.startTag(null, TAG_DEFAULT_ROOT);
 
@@ -344,8 +345,7 @@ public class FileUpdater {
         }
         Map<String, String> read = null;
         try (FileInputStream in = file.openRead()) {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(in, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(in);
 
             int type;
             while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
diff --git a/services/core/java/com/android/server/storage/CacheQuotaStrategy.java b/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
index aafadf912f7c..d2614e4698d1 100644
--- a/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
+++ b/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
@@ -46,6 +46,8 @@ import android.util.AtomicFile;
 import android.util.Pair;
 import android.util.Slog;
 import android.util.SparseLongArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -280,9 +282,8 @@ public class CacheQuotaStrategy implements RemoteCallback.OnResultListener {
     private void writeXmlToFile(List<CacheQuotaHint> processedRequests) {
         FileOutputStream fileStream = null;
         try {
-            XmlSerializer out = new FastXmlSerializer();
             fileStream = mPreviousValuesFile.startWrite();
-            out.setOutput(fileStream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fileStream);
             saveToXml(out, processedRequests, 0);
             mPreviousValuesFile.finishWrite(fileStream);
         } catch (Exception e) {
@@ -342,8 +343,7 @@ public class CacheQuotaStrategy implements RemoteCallback.OnResultListener {
 
     protected static Pair<Long, List<CacheQuotaHint>> readFromXml(InputStream inputStream)
             throws XmlPullParserException, IOException {
-        XmlPullParser parser = Xml.newPullParser();
-        parser.setInput(inputStream, StandardCharsets.UTF_8.name());
+        TypedXmlPullParser parser = Xml.resolvePullParser(inputStream);
 
         int eventType = parser.getEventType();
         while (eventType != XmlPullParser.START_TAG &&
diff --git a/services/core/java/com/android/server/timezone/PackageStatusStorage.java b/services/core/java/com/android/server/timezone/PackageStatusStorage.java
index 04f0871c9897..7652c438c295 100644
--- a/services/core/java/com/android/server/timezone/PackageStatusStorage.java
+++ b/services/core/java/com/android/server/timezone/PackageStatusStorage.java
@@ -25,6 +25,8 @@ import org.xmlpull.v1.XmlSerializer;
 
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import java.io.File;
@@ -265,8 +267,7 @@ final class PackageStatusStorage {
     private static XmlPullParser parseToPackageStatusTag(FileInputStream fis)
             throws ParseException {
         try {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             int type;
             while ((type = parser.next()) != END_DOCUMENT) {
                 final String tag = parser.getName();
@@ -315,8 +316,7 @@ final class PackageStatusStorage {
         FileOutputStream fos = null;
         try {
             fos = mPackageStatusFile.startWrite();
-            XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer serializer = Xml.resolveSerializer(fos);
             serializer.startDocument(null /* encoding */, true /* standalone */);
             final String namespace = null;
             serializer.startTag(namespace, TAG_PACKAGE_STATUS);
diff --git a/services/core/java/com/android/server/tv/PersistentDataStore.java b/services/core/java/com/android/server/tv/PersistentDataStore.java
index 8f2194c3c8b6..355c38544cb9 100644
--- a/services/core/java/com/android/server/tv/PersistentDataStore.java
+++ b/services/core/java/com/android/server/tv/PersistentDataStore.java
@@ -26,6 +26,7 @@ import android.os.UserHandle;
 import android.text.TextUtils;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.util.FastXmlSerializer;
@@ -167,8 +168,7 @@ final class PersistentDataStore {
 
         XmlPullParser parser;
         try {
-            parser = Xml.newPullParser();
-            parser.setInput(new BufferedInputStream(is), StandardCharsets.UTF_8.name());
+            parser = Xml.resolvePullParser(is);
             loadFromXml(parser);
         } catch (IOException | XmlPullParserException ex) {
             Slog.w(TAG, "Failed to load tv input manager persistent store data.", ex);
@@ -200,8 +200,7 @@ final class PersistentDataStore {
             os = mAtomicFile.startWrite();
             boolean success = false;
             try {
-                XmlSerializer serializer = new FastXmlSerializer();
-                serializer.setOutput(new BufferedOutputStream(os), StandardCharsets.UTF_8.name());
+                TypedXmlSerializer serializer = Xml.resolveSerializer(os);
                 saveToXml(serializer);
                 serializer.flush();
                 success = true;
diff --git a/services/core/java/com/android/server/uri/UriGrantsManagerService.java b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
index f6acc64bdaa0..bbb5374ea68a 100644
--- a/services/core/java/com/android/server/uri/UriGrantsManagerService.java
+++ b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
@@ -75,6 +75,8 @@ import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -657,8 +659,7 @@ public class UriGrantsManagerService extends IUriGrantsManager.Stub {
         FileInputStream fis = null;
         try {
             fis = mGrantFile.openRead();
-            final XmlPullParser in = Xml.newPullParser();
-            in.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser in = Xml.resolvePullParser(fis);
 
             int type;
             while ((type = in.next()) != END_DOCUMENT) {
@@ -1313,8 +1314,7 @@ public class UriGrantsManagerService extends IUriGrantsManager.Stub {
         try {
             fos = mGrantFile.startWrite(startTime);
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.startTag(null, TAG_URI_GRANTS);
             for (UriPermission.Snapshot perm : persist) {
diff --git a/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java b/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
index 8b0963b9f535..329589eea904 100644
--- a/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
+++ b/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
@@ -90,6 +90,8 @@ import android.util.EventLog;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseBooleanArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.Display;
 import android.view.DisplayInfo;
@@ -2910,10 +2912,9 @@ public class WallpaperManagerService extends IWallpaperManager.Stub
         FileOutputStream fstream = null;
         BufferedOutputStream stream = null;
         try {
-            XmlSerializer out = new FastXmlSerializer();
             fstream = new FileOutputStream(journal.chooseForWrite(), false);
             stream = new BufferedOutputStream(fstream);
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
 
             WallpaperData wallpaper;
@@ -3110,8 +3111,7 @@ public class WallpaperManagerService extends IWallpaperManager.Stub
         final DisplayData wpdData = getDisplayDataOrCreate(DEFAULT_DISPLAY);
         try {
             stream = new FileInputStream(file);
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
             int type;
             do {
diff --git a/services/core/java/com/android/server/wm/AppWarnings.java b/services/core/java/com/android/server/wm/AppWarnings.java
index 21b68095ef67..d40dea299ff6 100644
--- a/services/core/java/com/android/server/wm/AppWarnings.java
+++ b/services/core/java/com/android/server/wm/AppWarnings.java
@@ -27,6 +27,8 @@ import android.os.Message;
 import android.util.AtomicFile;
 import android.util.DisplayMetrics;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.util.FastXmlSerializer;
@@ -477,8 +479,7 @@ class AppWarnings {
         try {
             fos = mConfigFile.startWrite();
 
-            final XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
             out.startTag(null, "packages");
@@ -519,8 +520,7 @@ class AppWarnings {
         try {
             fis = mConfigFile.openRead();
 
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            final TypedXmlPullParser parser = Xml.resolvePullParser(fis);
 
             int eventType = parser.getEventType();
             while (eventType != XmlPullParser.START_TAG &&
diff --git a/services/core/java/com/android/server/wm/CompatModePackages.java b/services/core/java/com/android/server/wm/CompatModePackages.java
index 7e55f0aa2aa6..120cf7d1e2ac 100644
--- a/services/core/java/com/android/server/wm/CompatModePackages.java
+++ b/services/core/java/com/android/server/wm/CompatModePackages.java
@@ -35,6 +35,8 @@ import android.os.RemoteException;
 import android.util.AtomicFile;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.protolog.common.ProtoLog;
@@ -93,8 +95,7 @@ public final class CompatModePackages {
         FileInputStream fis = null;
         try {
             fis = mFile.openRead();
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(fis, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(fis);
             int eventType = parser.getEventType();
             while (eventType != XmlPullParser.START_TAG &&
                     eventType != XmlPullParser.END_DOCUMENT) {
@@ -362,8 +363,7 @@ public final class CompatModePackages {
 
         try {
             fos = mFile.startWrite();
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
             out.startTag(null, "compat-packages");
diff --git a/services/core/java/com/android/server/wm/DisplayWindowSettingsProvider.java b/services/core/java/com/android/server/wm/DisplayWindowSettingsProvider.java
index a7f7c480f78f..83da136e2005 100644
--- a/services/core/java/com/android/server/wm/DisplayWindowSettingsProvider.java
+++ b/services/core/java/com/android/server/wm/DisplayWindowSettingsProvider.java
@@ -28,6 +28,8 @@ import android.app.WindowConfiguration;
 import android.os.Environment;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.DisplayAddress;
 import android.view.DisplayInfo;
@@ -280,8 +282,7 @@ class DisplayWindowSettingsProvider implements SettingsProvider {
         FileData fileData = new FileData();
         boolean success = false;
         try {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
             int type;
             while ((type = parser.next()) != XmlPullParser.START_TAG
                     && type != XmlPullParser.END_DOCUMENT) {
@@ -419,8 +420,7 @@ class DisplayWindowSettingsProvider implements SettingsProvider {
 
         boolean success = false;
         try {
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
 
             out.startTag(null, "display-settings");
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyData.java b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyData.java
index 130cfd50b203..bdb7f79e2e31 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyData.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyData.java
@@ -25,6 +25,8 @@ import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.util.FastXmlSerializer;
@@ -154,8 +156,7 @@ class DevicePolicyData {
         FileOutputStream stream = null;
         try {
             stream = new FileOutputStream(file.chooseForWrite(), false);
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(stream);
             out.startDocument(null, true);
 
             out.startTag(null, "policies");
@@ -372,8 +373,7 @@ class DevicePolicyData {
         boolean needsRewrite = false;
         try {
             stream = new FileInputStream(file);
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
             int type;
             while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
index 9d634bc9e9d5..ad3a52fa2934 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
@@ -255,6 +255,8 @@ import android.util.Log;
 import android.util.Pair;
 import android.util.Slog;
 import android.util.SparseArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 import android.view.IWindowManager;
 import android.view.accessibility.AccessibilityManager;
@@ -14204,8 +14206,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
                 return null;
             }
             try (FileInputStream stream = new FileInputStream(bundleFile)) {
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(stream, null);
+                TypedXmlPullParser parser = Xml.resolvePullParser(stream);
                 parser.next();
                 return PersistableBundle.restoreFromXml(parser);
             } catch (IOException | XmlPullParserException | IllegalArgumentException e) {
@@ -14358,8 +14359,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
         FileOutputStream stream = null;
         try {
             stream = atomicFile.startWrite();
-            final XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(stream, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(stream);
             serializer.startDocument(null, true);
             serializer.startTag(null, TAG_TRANSFER_OWNERSHIP_BUNDLE);
             bundle.saveToXml(serializer);
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/Owners.java b/services/devicepolicy/java/com/android/server/devicepolicy/Owners.java
index cced359e8d5a..9e98fc5ff8b4 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/Owners.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/Owners.java
@@ -39,6 +39,8 @@ import android.util.Pair;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseIntArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -735,8 +737,7 @@ class Owners {
             FileOutputStream outputStream = null;
             try {
                 outputStream = f.startWrite();
-                final XmlSerializer out = new FastXmlSerializer();
-                out.setOutput(outputStream, StandardCharsets.UTF_8.name());
+                final TypedXmlSerializer out = Xml.resolveSerializer(outputStream);
 
                 // Root tag
                 out.startDocument(null, true);
@@ -776,8 +777,7 @@ class Owners {
             InputStream input = null;
             try {
                 input = f.openRead();
-                final XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(input, StandardCharsets.UTF_8.name());
+                final TypedXmlPullParser parser = Xml.resolvePullParser(input);
 
                 int type;
                 int depth = 0;
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/TransferOwnershipMetadataManager.java b/services/devicepolicy/java/com/android/server/devicepolicy/TransferOwnershipMetadataManager.java
index 4b66beaa2cb0..58ece0748d8b 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/TransferOwnershipMetadataManager.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/TransferOwnershipMetadataManager.java
@@ -24,6 +24,8 @@ import android.os.Environment;
 import android.text.TextUtils;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.VisibleForTesting;
@@ -84,8 +86,7 @@ class TransferOwnershipMetadataManager {
         FileOutputStream stream = null;
         try {
             stream = atomicFile.startWrite();
-            final XmlSerializer serializer = new FastXmlSerializer();
-            serializer.setOutput(stream, StandardCharsets.UTF_8.name());
+            final TypedXmlSerializer serializer = Xml.resolveSerializer(stream);
             serializer.startDocument(null, true);
             insertSimpleTag(serializer, TAG_USER_ID, Integer.toString(params.userId));
             insertSimpleTag(serializer,
@@ -122,8 +123,7 @@ class TransferOwnershipMetadataManager {
         Slog.d(TAG, "Loading TransferOwnershipMetadataManager from "
                 + transferOwnershipMetadataFile);
         try (FileInputStream stream = new FileInputStream(transferOwnershipMetadataFile)) {
-            final XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, null);
+            final TypedXmlPullParser parser = Xml.resolvePullParser(stream);
             return parseMetadataFile(parser);
         } catch (IOException | XmlPullParserException | IllegalArgumentException e) {
             Slog.e(TAG, "Caught exception while trying to load the "
diff --git a/services/tests/servicestests/src/com/android/server/pm/PackageInstallerSessionTest.java b/services/tests/servicestests/src/com/android/server/pm/PackageInstallerSessionTest.java
index 4a6e11bca613..bbb83b6b46cf 100644
--- a/services/tests/servicestests/src/com/android/server/pm/PackageInstallerSessionTest.java
+++ b/services/tests/servicestests/src/com/android/server/pm/PackageInstallerSessionTest.java
@@ -27,12 +27,13 @@ import android.content.pm.PackageInstaller;
 import android.platform.test.annotations.Presubmit;
 import android.util.AtomicFile;
 import android.util.Slog;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import androidx.test.runner.AndroidJUnit4;
 
 import com.android.internal.os.BackgroundThread;
-import com.android.internal.util.FastXmlSerializer;
 
 import libcore.io.IoUtils;
 
@@ -43,16 +44,13 @@ import org.junit.rules.TemporaryFolder;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlSerializer;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -200,8 +198,7 @@ public class PackageInstallerSessionTest {
         try {
             fos = mSessionsFile.startWrite();
 
-            XmlSerializer out = new FastXmlSerializer();
-            out.setOutput(fos, StandardCharsets.UTF_8.name());
+            TypedXmlSerializer out = Xml.resolveSerializer(fos);
             out.startDocument(null, true);
             out.startTag(null, TAG_SESSIONS);
             for (PackageInstallerSession session : sessions) {
@@ -227,8 +224,7 @@ public class PackageInstallerSessionTest {
         FileInputStream fis = null;
         try {
             fis = mSessionsFile.openRead();
-            final XmlPullParser in = Xml.newPullParser();
-            in.setInput(fis, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser in = Xml.resolvePullParser(fis);
 
             int type;
             while ((type = in.next()) != END_DOCUMENT) {
diff --git a/services/tests/servicestests/src/com/android/server/pm/PackageSignaturesTest.java b/services/tests/servicestests/src/com/android/server/pm/PackageSignaturesTest.java
index 7108490f80f8..89c3d5006347 100644
--- a/services/tests/servicestests/src/com/android/server/pm/PackageSignaturesTest.java
+++ b/services/tests/servicestests/src/com/android/server/pm/PackageSignaturesTest.java
@@ -24,6 +24,7 @@ import static org.junit.Assert.fail;
 import android.content.Context;
 import android.content.pm.PackageParser;
 import android.content.pm.Signature;
+import android.util.TypedXmlPullParser;
 import android.util.Xml;
 
 import androidx.test.InstrumentationRegistry;
@@ -38,7 +39,6 @@ import org.xmlpull.v1.XmlPullParser;
 
 import java.io.File;
 import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -137,7 +137,7 @@ public class PackageSignaturesTest {
         // first call to readXml should return the list with the expected signature, then the second
         // call should reference this signature and complete successfully with no new entries in the
         // List.
-        XmlPullParser parser = getXMLFromResources("xml/one-signer.xml");
+        TypedXmlPullParser parser = getXMLFromResources("xml/one-signer.xml");
         ArrayList<Signature> signatures = new ArrayList<>();
         mPackageSetting.signatures.readXml(parser, signatures);
         Set<String> expectedSignatures = createSetOfSignatures(FIRST_EXPECTED_SIGNATURE);
@@ -164,7 +164,7 @@ public class PackageSignaturesTest {
         // If the cert tag key attribute does not contain a valid public key then a
         // CertificateException should be thrown when attempting to build the SigningDetails; in
         // this case the signing details should be set to UNKNOWN.
-        XmlPullParser parser = getXMLFromResources(
+        TypedXmlPullParser parser = getXMLFromResources(
                 "xml/one-signer-invalid-public-key-cert-key.xml");
         ArrayList<Signature> signatures = new ArrayList<>();
         mPackageSetting.signatures.readXml(parser, signatures);
@@ -351,7 +351,7 @@ public class PackageSignaturesTest {
         // When rotating the signing key a developer is able to specify the capabilities granted to
         // the apps signed with the previous key. This test verifies a previous signing certificate
         // with the flags set to 0 does not have any capabilities.
-        XmlPullParser parser = getXMLFromResources("xml/two-signers-in-lineage-no-caps.xml");
+        TypedXmlPullParser parser = getXMLFromResources("xml/two-signers-in-lineage-no-caps.xml");
         ArrayList<Signature> signatures = new ArrayList<>();
         mPackageSetting.signatures.readXml(parser, signatures);
         // obtain the Signature in the list matching the previous signing certificate
@@ -377,7 +377,7 @@ public class PackageSignaturesTest {
      */
     private void verifyReadXmlReturnsExpectedSignatures(String xmlFile, int expectedSchemeVersion,
             String... expectedSignatureValues) throws Exception {
-        XmlPullParser parser = getXMLFromResources(xmlFile);
+        TypedXmlPullParser parser = getXMLFromResources(xmlFile);
         ArrayList<Signature> signatures = new ArrayList<>();
         mPackageSetting.signatures.readXml(parser, signatures);
         Set<String> expectedSignatures = createSetOfSignatures(expectedSignatureValues);
@@ -394,7 +394,7 @@ public class PackageSignaturesTest {
      */
     private void verifyReadXmlReturnsExpectedSignaturesAndLineage(String xmlFile,
             int schemeVersion, String... expectedSignatureValues) throws Exception {
-        XmlPullParser parser = getXMLFromResources(xmlFile);
+        TypedXmlPullParser parser = getXMLFromResources(xmlFile);
         ArrayList<Signature> signatures = new ArrayList<>();
         mPackageSetting.signatures.readXml(parser, signatures);
         Set<String> expectedSignatures = createSetOfSignatures(expectedSignatureValues);
@@ -447,11 +447,10 @@ public class PackageSignaturesTest {
         return result;
     }
 
-    private XmlPullParser getXMLFromResources(String xmlFile) throws Exception {
+    private TypedXmlPullParser getXMLFromResources(String xmlFile) throws Exception {
         InputStream xmlStream = mContext.getResources().getAssets().open(
                 TEST_RESOURCES_FOLDER + "/" + xmlFile);
-        XmlPullParser result = Xml.newPullParser();
-        result.setInput(xmlStream, StandardCharsets.UTF_8.name());
+        TypedXmlPullParser result = Xml.resolvePullParser(xmlStream);
         int type;
         // advance the parser to the first tag
         while ((type = result.next()) != XmlPullParser.START_TAG
diff --git a/services/usb/java/com/android/server/usb/UsbProfileGroupSettingsManager.java b/services/usb/java/com/android/server/usb/UsbProfileGroupSettingsManager.java
index 26ee03c25013..f63866054064 100644
--- a/services/usb/java/com/android/server/usb/UsbProfileGroupSettingsManager.java
+++ b/services/usb/java/com/android/server/usb/UsbProfileGroupSettingsManager.java
@@ -53,6 +53,8 @@ import android.util.Log;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.util.SparseIntArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -435,8 +437,7 @@ class UsbProfileGroupSettingsManager {
             FileInputStream fis = null;
             try {
                 fis = new FileInputStream(sSingleUserSettingsFile);
-                XmlPullParser parser = Xml.newPullParser();
-                parser.setInput(fis, StandardCharsets.UTF_8.name());
+                TypedXmlPullParser parser = Xml.resolvePullParser(fis);
 
                 XmlUtils.nextElement(parser);
                 while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
@@ -470,8 +471,7 @@ class UsbProfileGroupSettingsManager {
         FileInputStream stream = null;
         try {
             stream = mSettingsFile.openRead();
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(stream, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(stream);
 
             XmlUtils.nextElement(parser);
             while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
@@ -516,8 +516,7 @@ class UsbProfileGroupSettingsManager {
                 try {
                     fos = mSettingsFile.startWrite();
 
-                    FastXmlSerializer serializer = new FastXmlSerializer();
-                    serializer.setOutput(fos, StandardCharsets.UTF_8.name());
+                    TypedXmlSerializer serializer = Xml.resolveSerializer(fos);
                     serializer.startDocument(null, true);
                     serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output",
                                     true);
diff --git a/services/usb/java/com/android/server/usb/UsbUserPermissionManager.java b/services/usb/java/com/android/server/usb/UsbUserPermissionManager.java
index e20b1a4d6c89..5874b4b9fd3e 100644
--- a/services/usb/java/com/android/server/usb/UsbUserPermissionManager.java
+++ b/services/usb/java/com/android/server/usb/UsbUserPermissionManager.java
@@ -47,6 +47,8 @@ import android.util.ArrayMap;
 import android.util.AtomicFile;
 import android.util.Slog;
 import android.util.SparseBooleanArray;
+import android.util.TypedXmlPullParser;
+import android.util.TypedXmlSerializer;
 import android.util.Xml;
 
 import com.android.internal.annotations.GuardedBy;
@@ -355,8 +357,7 @@ class UsbUserPermissionManager {
         mAccessoryPersistentPermissionMap.clear();
 
         try (FileInputStream in = mPermissionsFile.openRead()) {
-            XmlPullParser parser = Xml.newPullParser();
-            parser.setInput(in, StandardCharsets.UTF_8.name());
+            TypedXmlPullParser parser = Xml.resolvePullParser(in);
 
             XmlUtils.nextElement(parser);
             while (parser.getEventType() != XmlPullParser.END_DOCUMENT) {
@@ -440,8 +441,7 @@ class UsbUserPermissionManager {
                 FileOutputStream out = null;
                 try {
                     out = mPermissionsFile.startWrite();
-                    FastXmlSerializer serializer = new FastXmlSerializer();
-                    serializer.setOutput(out, StandardCharsets.UTF_8.name());
+                    TypedXmlSerializer serializer = Xml.resolveSerializer(out);
                     serializer.startDocument(null, true);
                     serializer.startTag(null, "permissions");