Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cf501177 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Remove further unused code from... 

Merge "Remove further unused code from services/core/java/com/android/server/integrity/parser" into main am: d7e0f2f8 am: 3150c5c2

Original change: https://android-review.googlesource.com/c/platform/frameworks/base/+/3324554



Change-Id: I3e035996302b2682dc7c61e589c5972ec451fe91
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 9fea417e 3150c5c2

services/core/java/com/android/server/integrity/parser/LimitInputStream.java

deleted100644 → 0
+0 −84
Original line number Diff line number Diff line 
/*

 * 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.server.integrity.parser;



import java.io.FilterInputStream;

import java.io.IOException;

import java.io.InputStream;



/** An {@link InputStream} that basically truncates another {@link InputStream} */

public class LimitInputStream extends FilterInputStream {

    private int mReadBytes;

    private final int mLimit;



    public LimitInputStream(InputStream in, int limit) {

        super(in);

        if (limit < 0) {

            throw new IllegalArgumentException("limit " + limit + " cannot be negative");

        }

        mReadBytes = 0;

        mLimit = limit;

    }



    @Override

    public int available() throws IOException {

        return Math.min(super.available(), mLimit - mReadBytes);

    }



    @Override

    public int read() throws IOException {

        if (mReadBytes == mLimit) {

            return -1;

        }

        mReadBytes++;

        return super.read();

    }



    @Override

    public int read(byte[] b) throws IOException {

        return read(b, 0, b.length);

    }



    @Override

    public int read(byte[] b, int off, int len) throws IOException {

        if (len <= 0) {

            return 0;

        }

        int available = available();

        if (available <= 0) {

            return -1;

        }

        int result = super.read(b, off, Math.min(len, available));

        mReadBytes += result;

        return result;

    }



    @Override

    public long skip(long n) throws IOException {

        if (n <= 0) {

            return 0;

        }

        int available = available();

        if (available <= 0) {

            return 0;

        }

        int bytesToSkip = (int) Math.min(available, n);

        long bytesSkipped = super.skip(bytesToSkip);

        mReadBytes += (int) bytesSkipped;

        return bytesSkipped;

    }

}

services/core/java/com/android/server/integrity/parser/RandomAccessInputStream.java

deleted100644 → 0
+0 −97
Original line number Diff line number Diff line 
/*

 * 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.server.integrity.parser;



import java.io.IOException;

import java.io.InputStream;



/** A wrapper around {@link RandomAccessObject} to turn it into a {@link InputStream}. */

public class RandomAccessInputStream extends InputStream {



    private final RandomAccessObject mRandomAccessObject;



    private int mPosition;



    public RandomAccessInputStream(RandomAccessObject object) throws IOException {

        mRandomAccessObject = object;

        mPosition = 0;

    }



    /** Returns the position of the file pointer. */

    public int getPosition() {

        return mPosition;

    }



    /** See {@link RandomAccessObject#seek(int)} */

    public void seek(int position) throws IOException {

        mRandomAccessObject.seek(position);

        mPosition = position;

    }



    @Override

    public int available() throws IOException {

        return mRandomAccessObject.length() - mPosition;

    }



    @Override

    public void close() throws IOException {

        mRandomAccessObject.close();

    }



    @Override

    public int read() throws IOException {

        if (available() <= 0) {

            return -1;

        }

        mPosition++;

        return mRandomAccessObject.read();

    }



    @Override

    public int read(byte[] b) throws IOException {

        return read(b, 0, b.length);

    }



    @Override

    public int read(byte[] b, int off, int len) throws IOException {

        if (len <= 0) {

            return 0;

        }

        int available = available();

        if (available <= 0) {

            return -1;

        }

        int result = mRandomAccessObject.read(b, off, Math.min(len, available));

        mPosition += result;

        return result;

    }



    @Override

    public long skip(long n) throws IOException {

        if (n <= 0) {

            return 0;

        }

        int available = available();

        if (available <= 0) {

            return 0;

        }

        int skipAmount = (int) Math.min(available, n);

        mPosition += skipAmount;

        mRandomAccessObject.seek(mPosition);

        return skipAmount;

    }

}

services/core/java/com/android/server/integrity/parser/RandomAccessObject.java

deleted100644 → 0
+0 −133
Original line number Diff line number Diff line 
/*

 * 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.server.integrity.parser;



import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;



/** An interface for random access objects like RandomAccessFile or byte arrays. */

public abstract class RandomAccessObject {



    /** See {@link RandomAccessFile#seek(long)}. */

    public abstract void seek(int position) throws IOException;



    /** See {@link RandomAccessFile#read()}. */

    public abstract int read() throws IOException;



    /** See {@link RandomAccessFile#read(byte[], int, int)}. */

    public abstract int read(byte[] bytes, int off, int len) throws IOException;



    /** See {@link RandomAccessFile#close()}. */

    public abstract void close() throws IOException;



    /** See {@link java.io.RandomAccessFile#length()}. */

    public abstract int length();



    /** Static constructor from a file. */

    public static RandomAccessObject ofFile(File file) throws IOException {

        return new RandomAccessFileObject(file);

    }



    /** Static constructor from a byte array. */

    public static RandomAccessObject ofBytes(byte[] bytes) {

        return new RandomAccessByteArrayObject(bytes);

    }



    private static class RandomAccessFileObject extends RandomAccessObject {

        private final RandomAccessFile mRandomAccessFile;

        // We cache the length since File.length() invokes file IO.

        private final int mLength;



        RandomAccessFileObject(File file) throws IOException {

            long length = file.length();

            if (length > Integer.MAX_VALUE) {

                throw new IOException("Unsupported file size (too big) " + length);

            }



            mRandomAccessFile = new RandomAccessFile(file, /* mode= */ "r");

            mLength = (int) length;

        }



        @Override

        public void seek(int position) throws IOException {

            mRandomAccessFile.seek(position);

        }



        @Override

        public int read() throws IOException {

            return mRandomAccessFile.read();

        }



        @Override

        public int read(byte[] bytes, int off, int len) throws IOException {

            return mRandomAccessFile.read(bytes, off, len);

        }



        @Override

        public void close() throws IOException {

            mRandomAccessFile.close();

        }



        @Override

        public int length() {

            return mLength;

        }

    }



    private static class RandomAccessByteArrayObject extends RandomAccessObject {



        private final ByteBuffer mBytes;



        RandomAccessByteArrayObject(byte[] bytes) {

            mBytes = ByteBuffer.wrap(bytes);

        }



        @Override

        public void seek(int position) throws IOException {

            mBytes.position(position);

        }



        @Override

        public int read() throws IOException {

            if (!mBytes.hasRemaining()) {

                return -1;

            }



            return mBytes.get() & 0xFF;

        }



        @Override

        public int read(byte[] bytes, int off, int len) throws IOException {

            int bytesToCopy = Math.min(len, mBytes.remaining());

            if (bytesToCopy <= 0) {

                return 0;

            }

            mBytes.get(bytes, off, len);

            return bytesToCopy;

        }



        @Override

        public void close() throws IOException {}



        @Override

        public int length() {

            return mBytes.capacity();

        }

    }

}