am 7c6be10d: Remove iterators (DO NOT MERGE) (a64325f6) · Commits · e / os / android_frameworks_base

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);