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

Commit 7c6be10d authored by Craig Mautner's avatar Craig Mautner
Browse files

Remove iterators (DO NOT MERGE) 

Remove DisplayContentsIterator and AllWindowsIterator. These were cute
but they take up valuable resources. Iterate over ArrayList members
in their place.

Change-Id: Ie0c537608532cfb36f34d976cc6eacd21bad98cd
parent c0f5bb70

services/java/com/android/server/wm/InputMonitor.java

+39 −38
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ package com.android.server.wm; 
import com.android.server.input.InputManagerService;

import com.android.server.input.InputApplicationHandle;

import com.android.server.input.InputWindowHandle;

import com.android.server.wm.WindowManagerService.AllWindowsIterator;



import android.app.ActivityManagerNative;

import android.graphics.Rect;
@@ -31,7 +30,6 @@ import android.view.InputChannel; 
import android.view.KeyEvent;

import android.view.WindowManager;



import java.util.ArrayList;

import java.util.Arrays;



final class InputMonitor implements InputManagerService.WindowManagerCallbacks {
@@ -249,10 +247,12 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { 
        }



        // Add all windows on the default display.

        final AllWindowsIterator iterator = mService.new AllWindowsIterator(

                WindowManagerService.REVERSE_ITERATOR);

        while (iterator.hasNext()) {

            final WindowState child = iterator.next();

        final int numDisplays = mService.mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final WindowList windows =

                    mService.mDisplayContents.valueAt(displayNdx).getWindowList();

            for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {

                final WindowState child = windows.get(winNdx);

                final InputChannel inputChannel = child.mInputChannel;

                final InputWindowHandle inputWindowHandle = child.mInputWindowHandle;

                if (inputChannel == null || inputWindowHandle == null || child.mRemoved) {
@@ -290,6 +290,7 @@ final class InputMonitor implements InputManagerService.WindowManagerCallbacks { 
                            isVisible, hasFocus, hasWallpaper);

                }

            }

        }



        // Send windows to native code.

        mService.mInputManager.setInputWindows(mInputWindowHandles);

services/java/com/android/server/wm/WindowAnimator.java

+3 −4
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ import android.view.SurfaceControl; 
import android.view.WindowManagerPolicy;

import android.view.animation.Animation;



import com.android.server.wm.WindowManagerService.DisplayContentsIterator;

import com.android.server.wm.WindowManagerService.LayoutFields;



import java.io.PrintWriter;
@@ -627,9 +626,9 @@ public class WindowAnimator { 
        }



        boolean hasPendingLayoutChanges = false;

        DisplayContentsIterator iterator = mService.new DisplayContentsIterator();

        while (iterator.hasNext()) {

            final DisplayContent displayContent = iterator.next();

        final int numDisplays = mService.mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final DisplayContent displayContent = mService.mDisplayContents.valueAt(displayNdx);

            final int pendingChanges = getPendingLayoutChanges(displayContent.getDisplayId());

            if ((pendingChanges & WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER) != 0) {

                mBulkUpdateParams |= SET_WALLPAPER_ACTION_PENDING;

services/java/com/android/server/wm/WindowManagerService.java

+163 −207
Original line number Diff line number Diff line
@@ -450,7 +450,7 @@ public class WindowManagerService extends IWindowManager.Stub 
    String mLastANRState;



    /** All DisplayDontents in the world, kept here */

    private SparseArray<DisplayContent> mDisplayContents = new SparseArray<DisplayContent>();

    SparseArray<DisplayContent> mDisplayContents = new SparseArray<DisplayContent>();



    int mRotation = 0;

    int mForcedAppOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
@@ -4426,12 +4426,15 @@ public class WindowManagerService extends IWindowManager.Stub 


    void dumpWindowsLocked() {

        int i = 0;

        final AllWindowsIterator iterator = new AllWindowsIterator(REVERSE_ITERATOR);

        while (iterator.hasNext()) {

            final WindowState w = iterator.next();

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

            for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {

                final WindowState w = windows.get(winNdx);

                Slog.v(TAG, "  #" + i++ + ": " + w);

            }

        }

    }



    private int findWindowOffsetLocked(WindowList windows, int tokenPos) {

        final int NW = windows.size();
@@ -4574,9 +4577,9 @@ public class WindowManagerService extends IWindowManager.Stub 
                if (tmpRemoveAppWindowsLocked(wtoken)) {

                    if (DEBUG_REORDER) Slog.v(TAG, "Adding windows back in:");

                    if (DEBUG_REORDER) dumpWindowsLocked();

                    DisplayContentsIterator iterator = new DisplayContentsIterator();

                    while(iterator.hasNext()) {

                        final DisplayContent displayContent = iterator.next();

                    final int numDisplays = mDisplayContents.size();

                    for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                        final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

                        final WindowList windows = displayContent.getWindowList();

                        final int pos = findWindowOffsetLocked(windows, index);

                        final int newPos = reAddAppWindowsLocked(displayContent, pos, wtoken);
@@ -4628,9 +4631,9 @@ public class WindowManagerService extends IWindowManager.Stub 
        }



        // And now add them back at the correct place.

        DisplayContentsIterator iterator = new DisplayContentsIterator();

        while (iterator.hasNext()) {

            final DisplayContent displayContent = iterator.next();

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

            final WindowList windows = displayContent.getWindowList();

            // Where to start adding?

            int pos = findWindowOffsetLocked(windows, tokenPos);
@@ -4846,9 +4849,12 @@ public class WindowManagerService extends IWindowManager.Stub 
    @Override

    public void closeSystemDialogs(String reason) {

        synchronized(mWindowMap) {

            final AllWindowsIterator iterator = new AllWindowsIterator();

            while (iterator.hasNext()) {

                final WindowState w = iterator.next();

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

                final int numWindows = windows.size();

                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                    final WindowState w = windows.get(winNdx);

                    if (w.mHasSurface) {

                        try {

                            w.mClient.closeSystemDialogs(reason);
@@ -4858,6 +4864,7 @@ public class WindowManagerService extends IWindowManager.Stub 
                }

            }

        }

    }



    static float fixScale(float scale) {

        if (scale < 0) scale = 0;
@@ -4985,9 +4992,10 @@ public class WindowManagerService extends IWindowManager.Stub 
            mPolicy.setCurrentUserLw(newUserId);



            // Hide windows that should not be seen by the new user.

            DisplayContentsIterator iterator = new DisplayContentsIterator();

            while (iterator.hasNext()) {

                final WindowList windows = iterator.next().getWindowList();

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

                final WindowList windows = displayContent.getWindowList();

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

                    final WindowState win = windows.get(i);

                    if (win.isHiddenFromUserLocked()) {
@@ -5243,14 +5251,18 @@ public class WindowManagerService extends IWindowManager.Stub 
            // the background..)

            if (on) {

                boolean isVisible = false;

                final AllWindowsIterator iterator = new AllWindowsIterator();

                while (iterator.hasNext()) {

                    final WindowState ws = iterator.next();

                final int numDisplays = mDisplayContents.size();

                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

                    final int numWindows = windows.size();

                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                        final WindowState ws = windows.get(winNdx);

                        if (ws.mSession.mPid == pid && ws.isVisibleLw()) {

                            isVisible = true;

                            break;

                        }

                    }

                }

                if (!isVisible) {

                    return;

                }
@@ -5998,9 +6010,10 @@ public class WindowManagerService extends IWindowManager.Stub 
        WindowList windows = new WindowList();

        synchronized (mWindowMap) {

            //noinspection unchecked

            DisplayContentsIterator iterator = new DisplayContentsIterator();

            while(iterator.hasNext()) {

                windows.addAll(iterator.next().getWindowList());

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

                windows.addAll(displayContent.getWindowList());

            }

        }
@@ -6228,14 +6241,18 @@ public class WindowManagerService extends IWindowManager.Stub 
        }



        synchronized (mWindowMap) {

            final AllWindowsIterator iterator = new AllWindowsIterator();

            while (iterator.hasNext()) {

                final WindowState w = iterator.next();

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

                final int numWindows = windows.size();

                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                    final WindowState w = windows.get(winNdx);

                    if (System.identityHashCode(w) == hashCode) {

                        return w;

                    }

                }

            }

        }



        return null;

    }
@@ -6780,15 +6797,19 @@ public class WindowManagerService extends IWindowManager.Stub 
    // TODO(multidisplay): Call isScreenOn for each display.

    private void sendScreenStatusToClientsLocked() {

        final boolean on = mPowerManager.isScreenOn();

        final AllWindowsIterator iterator = new AllWindowsIterator();

        while (iterator.hasNext()) {

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

            final int numWindows = windows.size();

            for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                try {

                iterator.next().mClient.dispatchScreenState(on);

                    windows.get(winNdx).mClient.dispatchScreenState(on);

                } catch (RemoteException e) {

                    // Ignored

                }

            }

        }

    }



    // -------------------------------------------------------------

    // Async Handler
@@ -7629,9 +7650,9 @@ public class WindowManagerService extends IWindowManager.Stub 
    }



    final void rebuildAppWindowListLocked() {

        DisplayContentsIterator iterator = new DisplayContentsIterator();

        while (iterator.hasNext()) {

            rebuildAppWindowListLocked(iterator.next());

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            rebuildAppWindowListLocked(mDisplayContents.valueAt(displayNdx));

        }

    }
@@ -8594,9 +8615,9 @@ public class WindowManagerService extends IWindowManager.Stub 
            boolean focusDisplayed = false;

            boolean updateAllDrawn = false;



            DisplayContentsIterator iterator = new DisplayContentsIterator();

            while (iterator.hasNext()) {

                final DisplayContent displayContent = iterator.next();

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

                WindowList windows = displayContent.getWindowList();

                DisplayInfo displayInfo = displayContent.getDisplayInfo();

                final int displayId = displayContent.getDisplayId();
@@ -9035,9 +9056,9 @@ public class WindowManagerService extends IWindowManager.Stub 
            defaultDisplay.layoutNeeded = true;

        }



        DisplayContentsIterator iterator = new DisplayContentsIterator();

        while (iterator.hasNext()) {

            DisplayContent displayContent = iterator.next();

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

            if (displayContent.pendingLayoutChanges != 0) {

                displayContent.layoutNeeded = true;

            }
@@ -9224,9 +9245,10 @@ public class WindowManagerService extends IWindowManager.Stub 
    }



    private boolean needsLayout() {

        DisplayContentsIterator iterator = new DisplayContentsIterator();

        while (iterator.hasNext()) {

            if (iterator.next().layoutNeeded) {

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

            if (displayContent.layoutNeeded) {

                return true;

            }

        }
@@ -9287,10 +9309,12 @@ public class WindowManagerService extends IWindowManager.Stub 
            // window list to make sure we haven't left any dangling surfaces

            // around.



            AllWindowsIterator iterator = new AllWindowsIterator();

            Slog.i(TAG, "Out of memory for surface!  Looking for leaks...");

            while (iterator.hasNext()) {

                WindowState ws = iterator.next();

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

                final int numWindows = windows.size();

                for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                    final WindowState ws = windows.get(winNdx);

                    WindowStateAnimator wsa = ws.mWinAnimator;

                    if (wsa.mSurfaceControl != null) {

                        if (!mSessions.contains(wsa.mSession)) {
@@ -9319,13 +9343,16 @@ public class WindowManagerService extends IWindowManager.Stub 
                        }

                    }

                }

            }



            if (!leakedSurface) {

                Slog.w(TAG, "No leaked surfaces; killing applicatons!");

                SparseIntArray pidCandidates = new SparseIntArray();

                iterator = new AllWindowsIterator();

                while (iterator.hasNext()) {

                    WindowState ws = iterator.next();

                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                    final WindowList windows = mDisplayContents.valueAt(displayNdx).getWindowList();

                    final int numWindows = windows.size();

                    for (int winNdx = 0; winNdx < numWindows; ++winNdx) {

                        final WindowState ws = windows.get(winNdx);

                        if (mForceRemoves.contains(ws)) {

                            continue;

                        }
@@ -9347,6 +9374,7 @@ public class WindowManagerService extends IWindowManager.Stub 
                        }

                    }

                }

            }



            if (leakedSurface || killedApps) {

                // We managed to reclaim some memory, so get rid of the trouble
@@ -9974,9 +10002,9 @@ public class WindowManagerService extends IWindowManager.Stub 
    void dumpDisplayContentsLocked(PrintWriter pw, boolean dumpAll) {

        pw.println("WINDOW MANAGER DISPLAY CONTENTS (dumpsys window displays)");

        if (mDisplayReady) {

            DisplayContentsIterator dCIterator = new DisplayContentsIterator();

            while (dCIterator.hasNext()) {

                dCIterator.next().dump("  ", pw);

            final int numDisplays = mDisplayContents.size();

            for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                mDisplayContents.valueAt(displayNdx).dump("  ", pw);

            }

        } else {

            pw.println("  NO DISPLAY");
@@ -9992,15 +10020,18 @@ public class WindowManagerService extends IWindowManager.Stub 
    void dumpWindowsNoHeaderLocked(PrintWriter pw, boolean dumpAll,

            ArrayList<WindowState> windows) {

        int j = 0;

        final AllWindowsIterator iterator = new AllWindowsIterator(REVERSE_ITERATOR);

        while (iterator.hasNext()) {

            final WindowState w = iterator.next();

        final int numDisplays = mDisplayContents.size();

        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

            final WindowList windowList = mDisplayContents.valueAt(displayNdx).getWindowList();

            for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {

                final WindowState w = windowList.get(winNdx);

                if (windows == null || windows.contains(w)) {

                    pw.print("  Window #"); pw.print(j++); pw.print(' ');

                            pw.print(w); pw.println(":");

                    w.dump(pw, "    ", dumpAll || windows != null);

                }

            }

        }

        if (mInputMethodDialogs.size() > 0) {

            pw.println();

            pw.println("  Input method dialogs:");
@@ -10151,9 +10182,8 @@ public class WindowManagerService extends IWindowManager.Stub 
                    pw.print(" mDisplayEnabled="); pw.println(mDisplayEnabled);

            if (needsLayout()) {

                pw.print("  layoutNeeded on displays=");

                DisplayContentsIterator dcIterator = new DisplayContentsIterator();

                while (dcIterator.hasNext()) {

                    final DisplayContent displayContent = dcIterator.next();

                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                    final DisplayContent displayContent = mDisplayContents.valueAt(displayNdx);

                    if (displayContent.layoutNeeded) {

                        pw.print(displayContent.getDisplayId());

                    }
@@ -10187,14 +10217,18 @@ public class WindowManagerService extends IWindowManager.Stub 
        WindowList windows = new WindowList();

        if ("visible".equals(name)) {

            synchronized(mWindowMap) {

                final AllWindowsIterator iterator = new AllWindowsIterator(REVERSE_ITERATOR);

                while (iterator.hasNext()) {

                    final WindowState w = iterator.next();

                final int numDisplays = mDisplayContents.size();

                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                    final WindowList windowList =

                            mDisplayContents.valueAt(displayNdx).getWindowList();

                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {

                        final WindowState w = windowList.get(winNdx);

                        if (w.mWinAnimator.mSurfaceShown) {

                            windows.add(w);

                        }

                    }

                }

            }

        } else {

            int objectId = 0;

            // See if this is an object ID.
@@ -10204,9 +10238,11 @@ public class WindowManagerService extends IWindowManager.Stub 
            } catch (RuntimeException e) {

            }

            synchronized(mWindowMap) {

                final AllWindowsIterator iterator = new AllWindowsIterator(REVERSE_ITERATOR);

                while (iterator.hasNext()) {

                    final WindowState w = iterator.next();

                final int numDisplays = mDisplayContents.size();

                for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {

                    final WindowList windowList = mDisplayContents.valueAt(displayNdx).getWindowList();

                    for (int winNdx = windowList.size() - 1; winNdx >= 0; --winNdx) {

                        final WindowState w = windowList.get(winNdx);

                        if (name != null) {

                            if (w.mAttrs.getTitle().toString().contains(name)) {

                                windows.add(w);
@@ -10217,6 +10253,7 @@ public class WindowManagerService extends IWindowManager.Stub 
                    }

                }

            }

        }



        if (windows.size() <= 0) {

            return false;
@@ -10456,87 +10493,6 @@ public class WindowManagerService extends IWindowManager.Stub 
        return displayContent;

    }



    class DisplayContentsIterator implements Iterator<DisplayContent> {

        private int cur;



        @Override

        public boolean hasNext() {

            return cur < mDisplayContents.size();

        }



        @Override

        public DisplayContent next() {

            if (hasNext()) {

                return mDisplayContents.valueAt(cur++);

            }

            throw new NoSuchElementException();

        }



        @Override

        public void remove() {

            throw new IllegalArgumentException("AllDisplayContentIterator.remove not implemented");

        }

    }



    final static boolean REVERSE_ITERATOR = true;

    class AllWindowsIterator implements Iterator<WindowState> {

        private DisplayContent mDisplayContent;

        private DisplayContentsIterator mDisplayContentsIterator;

        private WindowList mWindowList;

        private int mWindowListIndex;

        private boolean mReverse;



        AllWindowsIterator() {

            mDisplayContentsIterator = new DisplayContentsIterator();

            mDisplayContent = mDisplayContentsIterator.next();

            mWindowList = mDisplayContent.getWindowList();

        }



        AllWindowsIterator(boolean reverse) {

            this();

            mReverse = reverse;

            mWindowListIndex = reverse ? mWindowList.size() - 1 : 0;

        }



        @Override

        public boolean hasNext() {

            if (mReverse) {

                return mWindowListIndex >= 0;

            }

            return mWindowListIndex < mWindowList.size();

        }



        @Override

        public WindowState next() {

            if (hasNext()) {

                WindowState win = mWindowList.get(mWindowListIndex);

                if (mReverse) {

                    mWindowListIndex--;

                    if (mWindowListIndex < 0 && mDisplayContentsIterator.hasNext()) {

                        mDisplayContent = mDisplayContentsIterator.next();

                        mWindowList = mDisplayContent.getWindowList();

                        mWindowListIndex = mWindowList.size() - 1;

                    }

                } else {

                    mWindowListIndex++;

                    if (mWindowListIndex >= mWindowList.size()

                            && mDisplayContentsIterator.hasNext()) {

                        mDisplayContent = mDisplayContentsIterator.next();

                        mWindowList = mDisplayContent.getWindowList();

                        mWindowListIndex = 0;

                    }

                }

                return win;

            }

            throw new NoSuchElementException();

        }



        @Override

        public void remove() {

            throw new IllegalArgumentException("AllWindowsIterator.remove not implemented");

        }

    }



    // There is an inherent assumption that this will never return null.

    public DisplayContent getDefaultDisplayContentLocked() {

        return getDisplayContentLocked(Display.DEFAULT_DISPLAY);