Merge "Removing the dependency on LooperExecutor in ViewCapture" into tm-qpr-dev

import android.content.Context;

import android.content.res.Resources;

import android.os.Handler;

import android.os.Looper;

import android.os.Message;

import android.os.Process;

import android.os.SystemClock;

import android.os.Trace;

import android.text.TextUtils;

import android.util.Base64;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.Future;

import java.util.concurrent.Executor;

import java.util.concurrent.FutureTask;

import java.util.function.Consumer;

import java.util.zip.GZIPOutputStream;

/**

    private final List<WindowListener> mListeners = new ArrayList<>();

    private final Context mContext;

    private final LooperExecutor mExecutor;

    private final Executor mExecutor;

    // Pool used for capturing view tree on the UI thread.

    private ViewRef mPool = new ViewRef();

        ViewIdProvider idProvider = new ViewIdProvider(mContext.getResources());

        // Collect all the tasks first so that all the tasks are posted on the executor

        List<Pair<String, Future<ExportedData>>> tasks = mListeners.stream()

                .map(l -> Pair.create(l.name, mExecutor.submit(() -> l.dumpToProto(idProvider))))

        List<Pair<String, FutureTask<ExportedData>>> tasks = mListeners.stream()

                .map(l -> {

                    FutureTask<ExportedData> task =

                            new FutureTask<ExportedData>(() -> l.dumpToProto(idProvider));

                    mExecutor.execute(task);

                    return Pair.create(l.name, task);

                })

                .collect(toList());

        tasks.forEach(pair -> {

        private final View mRoot;

        public final String name;

        private final Handler mHandler;

        private final ViewRef mViewRef = new ViewRef();

        private int mFrameIndexBg = -1;

        private final ViewPropertyRef[] mNodesBg = new ViewPropertyRef[MEMORY_SIZE];

        private boolean mDestroyed = false;

        private final Consumer<ViewRef> mCaptureCallback = this::captureViewPropertiesBg;

        WindowListener(View view, String name) {

            mRoot = view;

            this.name = name;

            mHandler = new Handler(mExecutor.getLooper(), this::captureViewPropertiesBg);

        }

        @Override

        public void onDraw() {

            Trace.beginSection("view_capture");

            captureViewTree(mRoot, mViewRef);

            Message m = Message.obtain(mHandler);

            m.obj = mViewRef.next;

            mHandler.sendMessage(m);

            ViewRef captured = mViewRef.next;

            if (captured != null) {

                captured.callback = mCaptureCallback;

                captured.creationTime = SystemClock.uptimeMillis();

                mExecutor.execute(captured);

            }

            mIsFirstFrame = false;

            Trace.endSection();

        }

         * back to the pool

         */

        @WorkerThread

        private boolean captureViewPropertiesBg(Message msg) {

            ViewRef viewRefStart = (ViewRef) msg.obj;

            long time = msg.getWhen();

            if (viewRefStart == null) {

                return false;

            }

        private void captureViewPropertiesBg(ViewRef viewRefStart) {

            long time = viewRefStart.creationTime;

            mFrameIndexBg++;

            if (mFrameIndexBg >= MEMORY_SIZE) {

                mFrameIndexBg = 0;

                viewRefEnd = viewRefEnd.next;

            }

            mNodesBg[mFrameIndexBg] = resultStart;

            return true;

        }

        private ViewPropertyRef findInLastFrame(int hashCode) {

        }

    }

    private static class ViewRef {

    private static class ViewRef implements Runnable {

        public View view;

        public int childCount = 0;

        public ViewRef next;

        public Consumer<ViewRef> callback = null;

        public long creationTime = 0;

        public void transferTo(ViewPropertyRef out) {

            out.childCount = this.childCount;

            out.visibility = view.getVisibility();

            out.willNotDraw = view.willNotDraw();

        }

        @Override

        public void run() {

            Consumer<ViewRef> oldCallback = callback;

            callback = null;

            if (oldCallback != null) {

                oldCallback.accept(this);

            }

        }

    }

    private static final class ViewIdProvider {