The Tor Browser: widget/gonk/libdisplay/GonkDisplayICS.cpp@fc2d59ddac77 (annotated)

widget/gonk/libdisplay/GonkDisplayICS.cpp@fc2d59ddac77 (annotated)

widget/gonk/libdisplay/GonkDisplayICS.cpp

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /* Copyright 2013 Mozilla Foundation and Mozilla contributors
  *
  * 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.
  */
 #include "GonkDisplayICS.h"
 #include <ui/FramebufferNativeWindow.h>
 #include <hardware/hardware.h>
 #include <hardware/gralloc.h>
 #include <hardware/hwcomposer.h>
 #include <hardware_legacy/power.h>
 #include <cutils/log.h>
 #include <fcntl.h>
 #include "mozilla/FileUtils.h"
 #include "mozilla/NullPtr.h"
 #include "mozilla/FileUtils.h"
 #include "BootAnimation.h"
 using namespace android;
 namespace {
 static const char* kSleepFile = "/sys/power/wait_for_fb_sleep";
 static const char* kWakeFile = "/sys/power/wait_for_fb_wake";
 static mozilla::GonkDisplay::OnEnabledCallbackType sEnabledCallback;
 static pthread_t sFramebufferWatchThread;
 static void *
 frameBufferWatcher(void *)
 {
     int len = 0;
     char buf;
     while (true) {
         // Cannot use epoll here because kSleepFile and kWakeFile are
         // always ready to read and blocking.
         {
             mozilla::ScopedClose fd(open(kSleepFile, O_RDONLY, 0));
             do {
                 len = read(fd.get(), &buf, 1);
             } while (len < 0 && errno == EINTR);
             NS_WARN_IF_FALSE(len >= 0, "WAIT_FOR_FB_SLEEP failed");
         }
         sEnabledCallback(false);
         {
             mozilla::ScopedClose fd(open(kWakeFile, O_RDONLY, 0));
             do {
                 len = read(fd.get(), &buf, 1);
             } while (len < 0 && errno == EINTR);
             NS_WARN_IF_FALSE(len >= 0, "WAIT_FOR_FB_WAKE failed");
         }
         sEnabledCallback(true);
     }
     return nullptr;
 }
 } // anonymous namespace
 namespace mozilla {
 static GonkDisplayICS* sGonkDisplay = nullptr;
 static int
 FramebufferNativeWindowCancelBufferNoop(ANativeWindow* aWindow,
     android_native_buffer_t* aBuffer)
 {
     return 0;
 }
 GonkDisplayICS::GonkDisplayICS()
     : mModule(nullptr)
     , mHwc(nullptr)
 {
     // Some gralloc HALs need this in order to open the
     // framebuffer device after we restart with the screen off.
     //
     // this *must* run BEFORE allocating the
     // FramebufferNativeWindow.
     set_screen_state(1);
     // For some devices, it takes a while for the framebuffer to become
     // usable. So we wait until the framebuffer has woken up before we
     // try to open it.
     {
         char buf;
         int len = 0;
         ScopedClose fd(open("/sys/power/wait_for_fb_wake", O_RDONLY, 0));
         do {
             len = read(fd.get(), &buf, 1);
         } while (len < 0 && errno == EINTR);
         if (len < 0) {
             LOGE("BootAnimation: wait_for_fb_sleep failed errno: %d", errno);
         }
     }
     mFBSurface = new FramebufferNativeWindow();
     // ICS FramebufferNativeWindow doesn't set the |cancelBuffer|
     // function pointer.
     // It will crash when deleting the EGL window surface.
     if (!mFBSurface->cancelBuffer) {
         mFBSurface->cancelBuffer = FramebufferNativeWindowCancelBufferNoop;
     }
     int err = hw_get_module(HWC_HARDWARE_MODULE_ID, &mModule);
     LOGW_IF(err, "%s module not found", HWC_HARDWARE_MODULE_ID);
     if (!err) {
         err = hwc_open(mModule, &mHwc);
         LOGE_IF(err, "%s device failed to initialize (%s)",
                  HWC_HARDWARE_COMPOSER, strerror(-err));
     }
     xdpi = mFBSurface->xdpi;
     const framebuffer_device_t *fbdev = mFBSurface->getDevice();
     surfaceformat = fbdev->format;
     StartBootAnimation();
 }
 GonkDisplayICS::~GonkDisplayICS()
 {
     if (mHwc)
         hwc_close(mHwc);
 }
 ANativeWindow*
 GonkDisplayICS::GetNativeWindow()
 {
     StopBootAnimation();
     return static_cast<ANativeWindow *>(mFBSurface.get());
 }
 void
 GonkDisplayICS::SetEnabled(bool enabled)
 {
     set_screen_state(enabled);
 }
 void
 GonkDisplayICS::OnEnabled(OnEnabledCallbackType callback)
 {
     if (sEnabledCallback)
         return;
     sEnabledCallback = callback;
     // Watching screen on/off state by using a pthread
     // which implicitly calls exit() when the main thread ends
     if (pthread_create(&sFramebufferWatchThread, NULL, frameBufferWatcher, NULL)) {
         NS_RUNTIMEABORT("Failed to create framebufferWatcherThread, aborting...");
     }
 }
 void*
 GonkDisplayICS::GetHWCDevice()
 {
     return mHwc;
 }
 void*
 GonkDisplayICS::GetFBSurface()
 {
     return mFBSurface.get();
 }
 bool
 GonkDisplayICS::SwapBuffers(EGLDisplay dpy, EGLSurface sur)
 {
     // Should be called when composition rendering is complete for a frame.
     // Only HWC v1.0 needs this call. ICS gonk always needs the call.
     mFBSurface->compositionComplete();
     if (!mHwc)
         return eglSwapBuffers(dpy, sur);
     mHwc->prepare(mHwc, nullptr);
     return !mHwc->set(mHwc, dpy, sur, 0);
 }
 ANativeWindowBuffer*
 GonkDisplayICS::DequeueBuffer()
 {
     ANativeWindow *window = static_cast<ANativeWindow *>(mFBSurface.get());
     ANativeWindowBuffer *buf = nullptr;
     window->dequeueBuffer(window, &buf);
     return buf;
 }
 bool
 GonkDisplayICS::QueueBuffer(ANativeWindowBuffer *buf)
 {
     ANativeWindow *window = static_cast<ANativeWindow *>(mFBSurface.get());
     return !window->queueBuffer(window, buf);
 }
 void
 GonkDisplayICS::UpdateFBSurface(EGLDisplay dpy, EGLSurface sur)
 {
     eglSwapBuffers(dpy, sur);
 }
 void
 GonkDisplayICS::SetFBReleaseFd(int fd)
 {
 }
 __attribute__ ((visibility ("default")))
 GonkDisplay*
 GetGonkDisplay()
 {
     if (!sGonkDisplay)
         sGonkDisplay = new GonkDisplayICS();
     return sGonkDisplay;
 }
 } // namespace mozilla

The Tor Browser / annotate

widget/gonk/libdisplay/GonkDisplayICS.cpp@fc2d59ddac77 (annotated)

widget/gonk/libdisplay/GonkDisplayICS.cpp