Remove Gonk build directories

1 files changed, 0 insertions, 703 deletions

diff --git a/widget/gonk/nativewindow/FakeSurfaceComposer.cpp b/widget/gonk/nativewindow/FakeSurfaceComposer.cpp
deleted file mode 100644
index 7e4a2a9d8..000000000
--- a/widget/gonk/nativewindow/FakeSurfaceComposer.cpp
+++ /dev/null
@@ -1,703 +0,0 @@
-/*
- * Copyright (C) 2007 The Android Open Source Project
- * Copyright (C) 2013 Mozilla Foundation
- *
- * 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.
- */
-
-#define LOG_TAG "FakeSurfaceComposer"
-//#define LOG_NDEBUG 0
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <errno.h>
-#include <cutils/atomic.h>
-#include <cutils/log.h>
-#include <cutils/properties.h>
-#include <private/android_filesystem_config.h>
-
-#include <gui/IDisplayEventConnection.h>
-#include <gui/GraphicBufferAlloc.h>
-#include <gui/Surface.h>
-#include <ui/DisplayInfo.h>
-
-#if ANDROID_VERSION >= 21
-#include <ui/Rect.h>
-#endif
-
-#include "../libdisplay/GonkDisplay.h"
-#include "../nsScreenManagerGonk.h"
-#include "FakeSurfaceComposer.h"
-#include "gfxPrefs.h"
-#include "MainThreadUtils.h"
-#include "mozilla/Assertions.h"
-#include "mozilla/layers/CompositorBridgeParent.h"
-#include "mozilla/layers/CompositorThread.h"
-#include "nsProxyRelease.h"
-#include "nsThreadUtils.h"
-
-using namespace mozilla;
-
-namespace android {
-
-/* static */
-void FakeSurfaceComposer::instantiate() {
-    defaultServiceManager()->addService(
-            String16("SurfaceFlinger"), new FakeSurfaceComposer());
-}
-
-FakeSurfaceComposer::FakeSurfaceComposer()
-    : BnSurfaceComposer()
-{
-}
-
-FakeSurfaceComposer::~FakeSurfaceComposer()
-{
-}
-
-status_t FakeSurfaceComposer::onTransact(uint32_t code, const Parcel& data,
-                                         Parcel* reply, uint32_t flags)
-{
-    switch (code) {
-        case CREATE_CONNECTION:
-        case CREATE_DISPLAY:
-        case SET_TRANSACTION_STATE:
-        case CAPTURE_SCREEN:
-        {
-            // codes that require permission check
-            IPCThreadState* ipc = IPCThreadState::self();
-            const int pid = ipc->getCallingPid();
-            const int uid = ipc->getCallingUid();
-            // Accept request only when uid is root.
-            if (uid != AID_ROOT) {
-                ALOGE("Permission Denial: "
-                        "can't access SurfaceFlinger pid=%d, uid=%d", pid, uid);
-                return PERMISSION_DENIED;
-            }
-            break;
-        }
-    }
-
-    return BnSurfaceComposer::onTransact(code, data, reply, flags);
-}
-
-sp<ISurfaceComposerClient> FakeSurfaceComposer::createConnection()
-{
-    return nullptr;
-}
-
-sp<IGraphicBufferAlloc> FakeSurfaceComposer::createGraphicBufferAlloc()
-{
-    sp<GraphicBufferAlloc> gba(new GraphicBufferAlloc());
-    return gba;
-}
-
-class DestroyDisplayRunnable : public Runnable {
-public:
-    DestroyDisplayRunnable(FakeSurfaceComposer* aComposer, ssize_t aIndex)
-        : mComposer(aComposer), mIndex(aIndex) { }
-    NS_IMETHOD Run() override {
-        MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
-        Mutex::Autolock _l(mComposer->mStateLock);
-        RefPtr<nsScreenManagerGonk> screenManager =
-            nsScreenManagerGonk::GetInstance();
-        screenManager->RemoveScreen(GonkDisplay::DISPLAY_VIRTUAL);
-        mComposer->mDisplays.removeItemsAt(mIndex);
-        return NS_OK;
-    }
-    sp<FakeSurfaceComposer> mComposer;
-    ssize_t mIndex;
-};
-
-sp<IBinder> FakeSurfaceComposer::createDisplay(const String8& displayName,
-        bool secure)
-{
-#if ANDROID_VERSION >= 19
-    class DisplayToken : public BBinder {
-        sp<FakeSurfaceComposer> composer;
-        virtual ~DisplayToken() {
-            MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
-            // no more references, this display must be terminated
-            Mutex::Autolock _l(composer->mStateLock);
-            ssize_t idx = composer->mDisplays.indexOfKey(this);
-            if (idx >= 0) {
-                nsCOMPtr<nsIRunnable> task(new DestroyDisplayRunnable(composer.get(), idx));
-                NS_DispatchToMainThread(task);
-            }
-        }
-    public:
-        DisplayToken(const sp<FakeSurfaceComposer>& composer)
-            : composer(composer) {
-        }
-    };
-
-    sp<BBinder> token = new DisplayToken(this);
-
-    Mutex::Autolock _l(mStateLock);
-    DisplayDeviceState info(HWC_DISPLAY_VIRTUAL);
-    info.displayName = displayName;
-    info.displayId = GonkDisplay::DISPLAY_VIRTUAL;
-    info.isSecure = secure;
-    mDisplays.add(token, info);
-    return token;
-#else
-    return nullptr;
-#endif
-}
-
-#if ANDROID_VERSION >= 19
-void FakeSurfaceComposer::destroyDisplay(const sp<IBinder>& display)
-{
-    Mutex::Autolock _l(mStateLock);
-
-    ssize_t idx = mDisplays.indexOfKey(display);
-    if (idx < 0) {
-        ALOGW("destroyDisplay: invalid display token");
-        return;
-    }
-
-    nsCOMPtr<nsIRunnable> task(new DestroyDisplayRunnable(this, idx));
-    NS_DispatchToMainThread(task);
-}
-#endif
-
-sp<IBinder> FakeSurfaceComposer::getBuiltInDisplay(int32_t id)
-{
-    // support only primary display
-    if (uint32_t(id) != HWC_DISPLAY_PRIMARY) {
-        return NULL;
-    }
-
-    if (!mPrimaryDisplay.get()) {
-        mPrimaryDisplay = new BBinder();
-    }
-    return mPrimaryDisplay;
-}
-
-void FakeSurfaceComposer::setTransactionState(
-        const Vector<ComposerState>& state,
-        const Vector<DisplayState>& displays,
-        uint32_t flags)
-{
-    Mutex::Autolock _l(mStateLock);
-    size_t count = displays.size();
-    for (size_t i=0 ; i<count ; i++) {
-        const DisplayState& s(displays[i]);
-        setDisplayStateLocked(s);
-    }
-}
-
-uint32_t FakeSurfaceComposer::setDisplayStateLocked(const DisplayState& s)
-{
-    ssize_t dpyIdx = mDisplays.indexOfKey(s.token);
-    if (dpyIdx < 0) {
-        return 0;
-    }
-
-    uint32_t flags = 0;
-    DisplayDeviceState& disp(mDisplays.editValueAt(dpyIdx));
-
-    if (!disp.isValid()) {
-        return 0;
-    }
-
-    const uint32_t what = s.what;
-    if (what & DisplayState::eSurfaceChanged) {
-        if (disp.surface->asBinder() != s.surface->asBinder()) {
-            disp.surface = s.surface;
-            flags |= eDisplayTransactionNeeded;
-        }
-    }
-    if (what & DisplayState::eLayerStackChanged) {
-        if (disp.layerStack != s.layerStack) {
-            disp.layerStack = s.layerStack;
-            flags |= eDisplayTransactionNeeded;
-        }
-    }
-    if (what & DisplayState::eDisplayProjectionChanged) {
-        if (disp.orientation != s.orientation) {
-            disp.orientation = s.orientation;
-            flags |= eDisplayTransactionNeeded;
-        }
-        if (disp.frame != s.frame) {
-            disp.frame = s.frame;
-            flags |= eDisplayTransactionNeeded;
-        }
-        if (disp.viewport != s.viewport) {
-            disp.viewport = s.viewport;
-            flags |= eDisplayTransactionNeeded;
-        }
-    }
-#if ANDROID_VERSION >= 21
-    if (what & DisplayState::eDisplaySizeChanged) {
-        if (disp.width != s.width) {
-            disp.width = s.width;
-            flags |= eDisplayTransactionNeeded;
-        }
-        if (disp.height != s.height) {
-            disp.height = s.height;
-            flags |= eDisplayTransactionNeeded;
-        }
-    }
-#endif
-
-    if (what & DisplayState::eSurfaceChanged) {
-        nsCOMPtr<nsIRunnable> runnable =
-            NS_NewRunnableFunction([&]() {
-                MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
-                RefPtr<nsScreenManagerGonk> screenManager = nsScreenManagerGonk::GetInstance();
-                screenManager->AddScreen(GonkDisplay::DISPLAY_VIRTUAL, disp.surface.get());
-            });
-        NS_DispatchToMainThread(runnable, NS_DISPATCH_SYNC);
-    }
-
-    return flags;
-}
-
-void FakeSurfaceComposer::bootFinished()
-{
-}
-
-bool FakeSurfaceComposer::authenticateSurfaceTexture(
-        const sp<IGraphicBufferProducer>& bufferProducer) const {
-    return false;
-}
-
-sp<IDisplayEventConnection> FakeSurfaceComposer::createDisplayEventConnection() {
-    return nullptr;
-}
-
-// ---------------------------------------------------------------------------
-// Capture screen into an IGraphiBufferProducer
-// ---------------------------------------------------------------------------
-
-class Barrier {
-public:
-    inline Barrier() : state(CLOSED) { }
-    inline ~Barrier() { }
-
-    // Release any threads waiting at the Barrier.
-    // Provides release semantics: preceding loads and stores will be visible
-    // to other threads before they wake up.
-    void open() {
-        Mutex::Autolock _l(lock);
-        state = OPENED;
-        cv.broadcast();
-    }
-
-    // Reset the Barrier, so wait() will block until open() has been called.
-    void close() {
-        Mutex::Autolock _l(lock);
-        state = CLOSED;
-    }
-
-    // Wait until the Barrier is OPEN.
-    // Provides acquire semantics: no subsequent loads or stores will occur
-    // until wait() returns.
-    void wait() const {
-        Mutex::Autolock _l(lock);
-        while (state == CLOSED) {
-            cv.wait(lock);
-        }
-    }
-private:
-    enum { OPENED, CLOSED };
-    mutable     Mutex       lock;
-    mutable     Condition   cv;
-    volatile    int         state;
-};
-
-/* The code below is here to handle b/8734824
- *
- * We create a IGraphicBufferProducer wrapper that forwards all calls
- * to the calling binder thread, where they are executed. This allows
- * the calling thread to be reused (on the other side) and not
- * depend on having "enough" binder threads to handle the requests.
- *
- */
-
-class GraphicProducerWrapper : public BBinder, public MessageHandler {
-    sp<IGraphicBufferProducer> impl;
-    sp<Looper> looper;
-    status_t result;
-    bool exitPending;
-    bool exitRequested;
-    mutable Barrier barrier;
-    volatile int32_t memoryBarrier;
-    uint32_t code;
-    Parcel const* data;
-    Parcel* reply;
-
-    enum {
-        MSG_API_CALL,
-        MSG_EXIT
-    };
-
-    /*
-     * this is called by our "fake" BpGraphicBufferProducer. We package the
-     * data and reply Parcel and forward them to the calling thread.
-     */
-    virtual status_t transact(uint32_t code,
-            const Parcel& data, Parcel* reply, uint32_t flags) {
-        this->code = code;
-        this->data = &data;
-        this->reply = reply;
-        android_atomic_acquire_store(0, &memoryBarrier);
-        if (exitPending) {
-            // if we've exited, we run the message synchronously right here
-            handleMessage(Message(MSG_API_CALL));
-        } else {
-            barrier.close();
-            looper->sendMessage(this, Message(MSG_API_CALL));
-            barrier.wait();
-        }
-        return NO_ERROR;
-    }
-
-    /*
-     * here we run on the binder calling thread. All we've got to do is
-     * call the real BpGraphicBufferProducer.
-     */
-    virtual void handleMessage(const Message& message) {
-        android_atomic_release_load(&memoryBarrier);
-        if (message.what == MSG_API_CALL) {
-            impl->asBinder()->transact(code, data[0], reply);
-            barrier.open();
-        } else if (message.what == MSG_EXIT) {
-            exitRequested = true;
-        }
-    }
-
-public:
-    GraphicProducerWrapper(const sp<IGraphicBufferProducer>& impl) :
-        impl(impl), looper(new Looper(true)), result(NO_ERROR),
-        exitPending(false), exitRequested(false) {
-    }
-
-    status_t waitForResponse() {
-        do {
-            looper->pollOnce(-1);
-        } while (!exitRequested);
-        return result;
-    }
-
-    void exit(status_t result) {
-        this->result = result;
-        exitPending = true;
-        looper->sendMessage(this, Message(MSG_EXIT));
-    }
-};
-
-status_t
-FakeSurfaceComposer::captureScreen(const sp<IBinder>& display
-                                 , const sp<IGraphicBufferProducer>& producer
-#if ANDROID_VERSION >= 21
-                                 , Rect sourceCrop
-#endif
-                                 , uint32_t reqWidth
-                                 , uint32_t reqHeight
-                                 , uint32_t minLayerZ
-                                 , uint32_t maxLayerZ
-#if ANDROID_VERSION >= 21
-                                 , bool useIdentityTransform
-                                 , Rotation rotation
-#elif ANDROID_VERSION < 19
-                                 , bool isCpuConsumer
-#endif
-                                  )
-{
-    if (display == 0 || producer == 0) {
-        return BAD_VALUE;
-    }
-
-    // Limit only to primary display
-    if (display != mPrimaryDisplay) {
-        return BAD_VALUE;
-    }
-
-    // this creates a "fake" BBinder which will serve as a "fake" remote
-    // binder to receive the marshaled calls and forward them to the
-    // real remote (a BpGraphicBufferProducer)
-    sp<GraphicProducerWrapper> wrapper = new GraphicProducerWrapper(producer);
-    // the asInterface() call below creates our "fake" BpGraphicBufferProducer
-    // which does the marshaling work forwards to our "fake remote" above.
-    sp<IGraphicBufferProducer> fakeProducer = IGraphicBufferProducer::asInterface(wrapper);
-
-    nsCOMPtr<nsIRunnable> runnable =
-        NS_NewRunnableFunction([&]() {
-            captureScreenImp(fakeProducer, reqWidth, reqHeight, wrapper.get());
-        });
-    NS_DispatchToMainThread(runnable);
-
-    status_t result = wrapper->waitForResponse();
-
-    return result;
-}
-
-class RunnableCallTask final : public Runnable
-{
-public:
-    explicit RunnableCallTask(nsIRunnable* aRunnable)
-        : mRunnable(aRunnable) {}
-
-    NS_IMETHOD Run() override
-    {
-        return mRunnable->Run();
-    }
-protected:
-    nsCOMPtr<nsIRunnable> mRunnable;
-};
-
-void
-FakeSurfaceComposer::captureScreenImp(const sp<IGraphicBufferProducer>& producer,
-                                      uint32_t reqWidth,
-                                      uint32_t reqHeight,
-                                      const sp<GraphicProducerWrapper>& wrapper)
-{
-    MOZ_ASSERT(NS_IsMainThread());
-    MOZ_ASSERT(wrapper.get());
-
-    RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen();
-
-    // get screen geometry
-    nsIntRect screenBounds = screen->GetNaturalBounds().ToUnknownRect();
-    const uint32_t hw_w = screenBounds.width;
-    const uint32_t hw_h = screenBounds.height;
-
-    if (reqWidth > hw_w || reqHeight > hw_h) {
-        ALOGE("size mismatch (%d, %d) > (%d, %d)",
-                reqWidth, reqHeight, hw_w, hw_h);
-        static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(BAD_VALUE);
-        return;
-    }
-
-    reqWidth  = (!reqWidth)  ? hw_w : reqWidth;
-    reqHeight = (!reqHeight) ? hw_h : reqHeight;
-
-    nsCOMPtr<nsIRunnable> runnable =
-        NS_NewRunnableFunction([screen, reqWidth, reqHeight, producer, wrapper]() {
-            // create a surface (because we're a producer, and we need to
-            // dequeue/queue a buffer)
-            sp<Surface> sur = new Surface(producer);
-            ANativeWindow* window = sur.get();
-            // The closure makes screen const and we can't call forget() on it.
-            RefPtr<nsScreenGonk> screenAlias = screen;
-
-            if (native_window_api_connect(window, NATIVE_WINDOW_API_EGL) != NO_ERROR) {
-                static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(BAD_VALUE);
-                NS_ReleaseOnMainThread(screenAlias.forget());
-                return;
-            }
-            uint32_t usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
-                             GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
-
-            int err = 0;
-            err = native_window_set_buffers_dimensions(window, reqWidth, reqHeight);
-            err |= native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
-            err |= native_window_set_buffers_format(window, HAL_PIXEL_FORMAT_RGBA_8888);
-            err |= native_window_set_usage(window, usage);
-
-            status_t result = NO_ERROR;
-            if (err == NO_ERROR) {
-                ANativeWindowBuffer* buffer;
-                result = native_window_dequeue_buffer_and_wait(window,  &buffer);
-                if (result == NO_ERROR) {
-                    nsresult rv = screen->MakeSnapshot(buffer);
-                    if (rv != NS_OK) {
-                        result = INVALID_OPERATION;
-                    }
-                    window->queueBuffer(window, buffer, -1);
-                }
-            } else {
-                result = BAD_VALUE;
-            }
-            native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
-            static_cast<GraphicProducerWrapper*>(producer->asBinder().get())->exit(result);
-            NS_ReleaseOnMainThread(screenAlias.forget());
-        });
-
-    layers::CompositorThreadHolder::Loop()->PostTask(
-        MakeAndAddRef<RunnableCallTask>(runnable));
-}
-
-#if ANDROID_VERSION >= 21
-void
-FakeSurfaceComposer::setPowerMode(const sp<IBinder>& display, int mode)
-{
-}
-
-status_t
-FakeSurfaceComposer::getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayInfo>* configs)
-{
-    if (configs == NULL) {
-        return BAD_VALUE;
-    }
-
-    // Limit DisplayConfigs only to primary display
-    if (!display.get() || display != mPrimaryDisplay) {
-        return NAME_NOT_FOUND;
-    }
-
-    configs->clear();
-    DisplayInfo info = DisplayInfo();
-
-    nsCOMPtr<nsIRunnable> runnable =
-        NS_NewRunnableFunction([&]() {
-            MOZ_ASSERT(NS_IsMainThread());
-            getPrimaryDisplayInfo(&info);
-        });
-    NS_DispatchToMainThread(runnable, NS_DISPATCH_SYNC);
-
-    configs->push_back(info);
-    return NO_ERROR;
-}
-
-status_t
-FakeSurfaceComposer::getDisplayStats(const sp<IBinder>& display, DisplayStatInfo* stats)
-{
-    return INVALID_OPERATION;
-}
-
-int
-FakeSurfaceComposer::getActiveConfig(const sp<IBinder>& display)
-{
-   // Only support primary display.
-   if (display.get() && (display == mPrimaryDisplay)) {
-       return 0;
-   }
-   return INVALID_OPERATION;
-}
-
-status_t
-FakeSurfaceComposer::setActiveConfig(const sp<IBinder>& display, int id)
-{
-    return INVALID_OPERATION;
-}
-
-status_t
-FakeSurfaceComposer::clearAnimationFrameStats()
-{
-    return INVALID_OPERATION;
-}
-
-status_t
-FakeSurfaceComposer::getAnimationFrameStats(FrameStats* outStats) const
-{
-    return INVALID_OPERATION;
-}
-#else
-void
-FakeSurfaceComposer::blank(const sp<IBinder>& display)
-{
-}
-
-void
-FakeSurfaceComposer::unblank(const sp<IBinder>& display)
-{
-}
-
-status_t
-FakeSurfaceComposer::getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info)
-{
-    if (info == NULL) {
-        return BAD_VALUE;
-    }
-
-    // Limit DisplayConfigs only to primary display
-    if (!display.get() || display != mPrimaryDisplay) {
-        return NAME_NOT_FOUND;
-    }
-
-    nsCOMPtr<nsIRunnable> runnable =
-        NS_NewRunnableFunction([&]() {
-            MOZ_ASSERT(NS_IsMainThread());
-            getPrimaryDisplayInfo(info);
-        });
-    NS_DispatchToMainThread(runnable, NS_DISPATCH_SYNC);
-
-    return NO_ERROR;
-}
-#endif
-
-#define VSYNC_EVENT_PHASE_OFFSET_NS 0
-#define SF_VSYNC_EVENT_PHASE_OFFSET_NS 0
-
-void
-FakeSurfaceComposer::getPrimaryDisplayInfo(DisplayInfo* info)
-{
-    MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");
-
-    // Implementation mimic android SurfaceFlinger::getDisplayConfigs().
-
-    class Density {
-        static int getDensityFromProperty(char const* propName) {
-            char property[PROPERTY_VALUE_MAX];
-            int density = 0;
-            if (property_get(propName, property, NULL) > 0) {
-                density = atoi(property);
-            }
-            return density;
-        }
-    public:
-        static int getEmuDensity() {
-            return getDensityFromProperty("qemu.sf.lcd_density"); }
-        static int getBuildDensity()  {
-            return getDensityFromProperty("ro.sf.lcd_density"); }
-    };
-
-    RefPtr<nsScreenGonk> screen = nsScreenManagerGonk::GetPrimaryScreen();
-
-    float xdpi = screen->GetDpi();
-    float ydpi = screen->GetDpi();
-    int fps = 60; // XXX set a value from hwc hal
-    nsIntRect screenBounds = screen->GetNaturalBounds().ToUnknownRect();
-
-    // The density of the device is provided by a build property
-    float density = Density::getBuildDensity() / 160.0f;
-    if (density == 0) {
-        // the build doesn't provide a density -- this is wrong!
-        // use xdpi instead
-        ALOGE("ro.sf.lcd_density must be defined as a build property");
-        density = xdpi / 160.0f;
-    }
-    info->density = density;
-    info->orientation = screen->EffectiveScreenRotation();
-
-    info->w = screenBounds.width;
-    info->h = screenBounds.height;
-    info->xdpi = xdpi;
-    info->ydpi = ydpi;
-    info->fps = fps;
-#if ANDROID_VERSION >= 21
-    info->appVsyncOffset = VSYNC_EVENT_PHASE_OFFSET_NS;
-
-    // This is how far in advance a buffer must be queued for
-    // presentation at a given time.  If you want a buffer to appear
-    // on the screen at time N, you must submit the buffer before
-    // (N - presentationDeadline).
-    //
-    // Normally it's one full refresh period (to give SF a chance to
-    // latch the buffer), but this can be reduced by configuring a
-    // DispSync offset.  Any additional delays introduced by the hardware
-    // composer or panel must be accounted for here.
-    //
-    // We add an additional 1ms to allow for processing time and
-    // differences between the ideal and actual refresh rate.
-    info->presentationDeadline =
-            (1e9 / fps) - SF_VSYNC_EVENT_PHASE_OFFSET_NS + 1000000;
-#endif
-    // All non-virtual displays are currently considered secure.
-    info->secure = true;
-}
-
-}; // namespace android