Merge "WakeLogLog: remove expensive mSavedAcquisitions work" into main

package com.android.server.power;

import android.annotation.Nullable;

import android.content.Context;

import android.content.pm.PackageManager;

import android.os.PowerManager;

import java.io.PrintWriter;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.ConcurrentModificationException;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.Objects;

import java.util.TreeMap;

/**

 * Simple Log for wake lock events. Optimized to reduce memory usage.

                int numEvents = 0;

                int numResets = 0;

                SparseArray<String[]> uidToPackagesCache = new SparseArray();

                for (int i = 0; i < mLog.mSavedAcquisitions.size(); i++) {

                for (LogEntry entry : mLog.mSavedAcquisitions.values()) {

                    numEvents++;

                    LogEntry entry = mLog.mSavedAcquisitions.get(i);

                    entry.updatePackageName(uidToPackagesCache, mContext.getPackageManager());

                    if (DEBUG) {

                        pw.print("Saved acquisition no. " + i);

                    }

                    entry.dump(pw, mDumpsysDateFormat);

                }

         * Wake lock acquisition events should continue to be printed until their corresponding

         * release event is removed from the log.

         */

        private final List<LogEntry> mSavedAcquisitions;

        private final TreeMap<TagData, LogEntry> mSavedAcquisitions;

        TheLog(Injector injector, EntryByteTranslator translator, TagDatabase tagDatabase) {

            final int logSize = Math.max(injector.getLogSize(), LOG_SIZE_MIN);

                }

            });

            mSavedAcquisitions = new ArrayList();

            mSavedAcquisitions = new TreeMap<TagData, LogEntry>();

        }

        /**

            // Copy the contents of the start of the buffer to our temporary buffer.

            LogEntry entry = readEntryAt(mStart, mStartTime, null);

            if (entry.tag != null) {

                if (entry.type == TYPE_ACQUIRE) {

                // We'll continue to print the event until the corresponding release event is also

                // removed from the log.

                mSavedAcquisitions.add(entry);

                    // We'll continue to print the event until the corresponding release event is

                    // also removed from the log.

                    mSavedAcquisitions.put(entry.tag, entry);

                } else if (entry.type == TYPE_RELEASE) {

                    // We no longer need to print the corresponding acquire event.

                for (int i = 0; i < mSavedAcquisitions.size(); i++) {

                    if (Objects.equals(mSavedAcquisitions.get(i).tag, entry.tag)) {

                        mSavedAcquisitions.remove(i);

                        break;

                    }

                    LogEntry removed = mSavedAcquisitions.remove(entry.tag);

                }

            }

            if (DEBUG) {

     * Contains both the wake lock tag data (tag + ownerUid) as well as index and last-used

     * time data as it relates to the tag-database.

     */

    static class TagData {

        public String tag;  // Wake lock tag

    static class TagData implements Comparable<TagData> {

        @Nullable public String tag;  // Wake lock tag

        public int ownerUid;  // Wake lock owner Uid

        public int index;  // Index of the tag in the tag-database

        public long lastUsedTime;  // Last time that this entry was used

            if (this == o) {

                return true;

            }

            if (o instanceof TagData) {

            if (o != null && o instanceof TagData) {

                TagData other = (TagData) o;

                return TextUtils.equals(tag, other.tag) && ownerUid == other.ownerUid;

                return ownerUid == other.ownerUid && TextUtils.equals(tag, other.tag);

            }

            return false;

        }

            bytes += 8;  // lastUsedTime

            return bytes;

        }

        @Override

        public int hashCode() {

            int result = ownerUid;

            result = 31 * result + tag.hashCode();

            return result;

        }

        @Override

        public int compareTo(TagData other) {

            if (other == null) {

                return -1;

            }

            return Long.compare(lastUsedTime, other.lastUsedTime);

        }

    }

    /**