Merge "Remove legacy callDrawGlFunction2 from HWUI" (ee26d1ef) · Commits · e / os / android_frameworks_base

core/java/android/view/ViewRootImpl.java

+10 −19

Original line number	Diff line number	Diff line
		@@ -1227,28 +1227,19 @@ public final class ViewRootImpl implements ViewParent,
		}
		}

		@UnsupportedAppUsage
		public void detachFunctor(long functor) {
		if (mAttachInfo.mThreadedRenderer != null) {
		// Fence so that any pending invokeFunctor() messages will be processed
		// before we return from detachFunctor.
		mAttachInfo.mThreadedRenderer.stopDrawing();
		}
		}
		/**
		* Does nothing; Here only because of @UnsupportedAppUsage
		*/
		@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R,
		publicAlternatives = "Use {@link android.webkit.WebView} instead")
		public void detachFunctor(long functor) { }

		/**
		* Schedules the functor for execution in either kModeProcess or
		* kModeProcessNoContext, depending on whether or not there is an EGLContext.
		*
		* @param functor The native functor to invoke
		* @param waitForCompletion If true, this will not return until the functor
		* has invoked. If false, the functor may be invoked
		* asynchronously.
		* Does nothing; Here only because of @UnsupportedAppUsage
		*/
		@UnsupportedAppUsage
		public static void invokeFunctor(long functor, boolean waitForCompletion) {
		ThreadedRenderer.invokeFunctor(functor, waitForCompletion);
		}
		@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R,
		publicAlternatives = "Use {@link android.webkit.WebView} instead")
		public static void invokeFunctor(long functor, boolean waitForCompletion) { }

		/**
		* @param animator animator to register with the hardware renderer

core/java/android/webkit/WebViewDelegate.java

+8 −40

Original line number	Diff line number	Diff line
		@@ -77,73 +77,41 @@ public final class WebViewDelegate {
		}

		/**
		* Returns {@code true} if the draw GL functor can be invoked (see {@link #invokeDrawGlFunctor})
		* and {@code false} otherwise.
		*
		* Throws {@link UnsupportedOperationException}
		* @deprecated Use {@link #drawWebViewFunctor(Canvas, int)}
		*/
		@Deprecated
		public boolean canInvokeDrawGlFunctor(View containerView) {
		return true;
		throw new UnsupportedOperationException();
		}

		/**
		* Invokes the draw GL functor. If waitForCompletion is {@code false} the functor
		* may be invoked asynchronously.
		*
		* @param nativeDrawGLFunctor the pointer to the native functor that implements
		* system/core/include/utils/Functor.h
		* Throws {@link UnsupportedOperationException}
		* @deprecated Use {@link #drawWebViewFunctor(Canvas, int)}
		*/
		@Deprecated
		public void invokeDrawGlFunctor(View containerView, long nativeDrawGLFunctor,
		boolean waitForCompletion) {
		ViewRootImpl.invokeFunctor(nativeDrawGLFunctor, waitForCompletion);
		throw new UnsupportedOperationException();
		}

		/**
		* Calls the function specified with the nativeDrawGLFunctor functor pointer. This
		* functionality is used by the WebView for calling into their renderer from the
		* framework display lists.
		*
		* @param canvas a hardware accelerated canvas (see {@link Canvas#isHardwareAccelerated()})
		* @param nativeDrawGLFunctor the pointer to the native functor that implements
		* system/core/include/utils/Functor.h
		* @throws IllegalArgumentException if the canvas is not hardware accelerated
		* Throws {@link UnsupportedOperationException}
		* @deprecated Use {@link #drawWebViewFunctor(Canvas, int)}
		*/
		@Deprecated
		public void callDrawGlFunction(Canvas canvas, long nativeDrawGLFunctor) {
		if (!(canvas instanceof RecordingCanvas)) {
		// Canvas#isHardwareAccelerated() is only true for subclasses of HardwareCanvas.
		throw new IllegalArgumentException(canvas.getClass().getName()
		+ " is not a DisplayList canvas");
		}
		((RecordingCanvas) canvas).drawGLFunctor2(nativeDrawGLFunctor, null);
		throw new UnsupportedOperationException();
		}

		/**
		* Calls the function specified with the nativeDrawGLFunctor functor pointer. This
		* functionality is used by the WebView for calling into their renderer from the
		* framework display lists.
		*
		* @param canvas a hardware accelerated canvas (see {@link Canvas#isHardwareAccelerated()})
		* @param nativeDrawGLFunctor the pointer to the native functor that implements
		* system/core/include/utils/Functor.h
		* @param releasedRunnable Called when this nativeDrawGLFunctor is no longer referenced by this
		* canvas, so is safe to be destroyed.
		* @throws IllegalArgumentException if the canvas is not hardware accelerated
		* Throws {@link UnsupportedOperationException}
		* @deprecated Use {@link #drawWebViewFunctor(Canvas, int)}
		*/
		@Deprecated
		public void callDrawGlFunction(@NonNull Canvas canvas, long nativeDrawGLFunctor,
		@Nullable Runnable releasedRunnable) {
		if (!(canvas instanceof RecordingCanvas)) {
		// Canvas#isHardwareAccelerated() is only true for subclasses of HardwareCanvas.
		throw new IllegalArgumentException(canvas.getClass().getName()
		+ " is not a DisplayList canvas");
		}
		((RecordingCanvas) canvas).drawGLFunctor2(nativeDrawGLFunctor, releasedRunnable);
		throw new UnsupportedOperationException();
		}

		/**

graphics/java/android/graphics/HardwareRenderer.java

+0 −7

Original line number	Diff line number	Diff line
		@@ -872,11 +872,6 @@ public class HardwareRenderer {
		}
		}

		/** @hide */
		public static void invokeFunctor(long functor, boolean waitForCompletion) {
		nInvokeFunctor(functor, waitForCompletion);
		}

		/**
		* b/68769804: For low FPS experiments.
		*
		@@ -1246,8 +1241,6 @@ public class HardwareRenderer {

		private static native void nRegisterVectorDrawableAnimator(long rootRenderNode, long animator);

		private static native void nInvokeFunctor(long functor, boolean waitForCompletion);

		private static native long nCreateTextureLayer(long nativeProxy);

		private static native void nBuildLayer(long nativeProxy, long node);

graphics/java/android/graphics/RecordingCanvas.java

+1 −44

Original line number	Diff line number	Diff line
		@@ -17,11 +17,9 @@
		package android.graphics;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.util.Pools.SynchronizedPool;

		import dalvik.annotation.optimization.CriticalNative;
		import dalvik.annotation.optimization.FastNative;

		/**
		* A Canvas implementation that records view system drawing operations for deferred rendering.
		@@ -146,43 +144,9 @@ public final class RecordingCanvas extends BaseRecordingCanvas {
		}

		///////////////////////////////////////////////////////////////////////////
		// Functor
		// WebView
		///////////////////////////////////////////////////////////////////////////

		/**
		* Records the functor specified with the drawGLFunction function pointer. This is
		* functionality used by webview for calling into their renderer from our display lists.
		*
		* @param drawGLFunction A native function pointer
		*
		* @hide
		* @deprecated Use {@link #drawWebViewFunctor(int)}
		*/
		@Deprecated
		public void callDrawGLFunction2(long drawGLFunction) {
		nCallDrawGLFunction(mNativeCanvasWrapper, drawGLFunction, null);
		}

		/**
		* Records the functor specified with the drawGLFunction function pointer. This is
		* functionality used by webview for calling into their renderer from our display lists.
		*
		* @param drawGLFunctor A native function pointer
		* @param releasedCallback Called when the display list is destroyed, and thus
		* the functor is no longer referenced by this canvas's display list.
		*
		* NOTE: The callback does not necessarily mean that there are no longer
		* any references to the functor, just that the reference from this specific
		* canvas's display list has been released.
		*
		* @hide
		* @deprecated Use {@link #drawWebViewFunctor(int)}
		*/
		@Deprecated
		public void drawGLFunctor2(long drawGLFunctor, @Nullable Runnable releasedCallback) {
		nCallDrawGLFunction(mNativeCanvasWrapper, drawGLFunctor, releasedCallback);
		}

		/**
		* Calls the provided functor that was created via WebViewFunctor_create()
		* @hide
		@@ -273,13 +237,6 @@ public final class RecordingCanvas extends BaseRecordingCanvas {
		}


		// ------------------ Fast JNI ------------------------

		@FastNative
		private static native void nCallDrawGLFunction(long renderer,
		long drawGLFunction, Runnable releasedCallback);


		// ------------------ Critical JNI ------------------------

		@CriticalNative

libs/hwui/GlFunctorLifecycleListener.h

deleted100644 → 0

+0 −32

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#pragma once

		#include <utils/Functor.h>
		#include <utils/RefBase.h>

		namespace android {
		namespace uirenderer {

		class GlFunctorLifecycleListener : public VirtualLightRefBase {
		public:
		virtual ~GlFunctorLifecycleListener() {}
		virtual void onGlFunctorReleased(Functor* functor) = 0;
		};

		} // namespace uirenderer
		} // namespace android