The Tor Browser: widget/gonk/nativewindow/GonkConsumerBaseKK.cpp@b8a032363ba2 (annotated)

widget/gonk/nativewindow/GonkConsumerBaseKK.cpp@b8a032363ba2 (annotated)

widget/gonk/nativewindow/GonkConsumerBaseKK.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
  * Copyright (C) 2010 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 "GonkConsumerBase"
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 //#define LOG_NDEBUG 0
 #define EGL_EGLEXT_PROTOTYPES
 #include <hardware/hardware.h>
 #include <gui/IGraphicBufferAlloc.h>
 #include <utils/Log.h>
 #include <utils/String8.h>
 #include "GonkConsumerBaseKK.h"
 // Macros for including the GonkConsumerBase name in log messages
 #define CB_LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
 #define CB_LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
 #define CB_LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
 #define CB_LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
 #define CB_LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
 namespace android {
 // Get an ID that's unique within this process.
 static int32_t createProcessUniqueId() {
     static volatile int32_t globalCounter = 0;
     return android_atomic_inc(&globalCounter);
 }
 GonkConsumerBase::GonkConsumerBase(const sp<GonkBufferQueue>& bufferQueue, bool controlledByApp) :
         mAbandoned(false),
         mConsumer(bufferQueue) {
     // Choose a name using the PID and a process-unique ID.
     mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());
     // Note that we can't create an sp<...>(this) in a ctor that will not keep a
     // reference once the ctor ends, as that would cause the refcount of 'this'
     // dropping to 0 at the end of the ctor.  Since all we need is a wp<...>
     // that's what we create.
     wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
     sp<IConsumerListener> proxy = new GonkBufferQueue::ProxyConsumerListener(listener);
     status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
     if (err != NO_ERROR) {
         CB_LOGE("GonkConsumerBase: error connecting to GonkBufferQueue: %s (%d)",
                 strerror(-err), err);
     } else {
         mConsumer->setConsumerName(mName);
     }
 }
 GonkConsumerBase::~GonkConsumerBase() {
     CB_LOGV("~GonkConsumerBase");
     Mutex::Autolock lock(mMutex);
     // Verify that abandon() has been called before we get here.  This should
     // be done by GonkConsumerBase::onLastStrongRef(), but it's possible for a
     // derived class to override that method and not call
     // GonkConsumerBase::onLastStrongRef().
     LOG_ALWAYS_FATAL_IF(!mAbandoned, "[%s] ~GonkConsumerBase was called, but the "
         "consumer is not abandoned!", mName.string());
 }
 void GonkConsumerBase::onLastStrongRef(const void* id) {
     abandon();
 }
 void GonkConsumerBase::freeBufferLocked(int slotIndex) {
     CB_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
     mSlots[slotIndex].mGraphicBuffer = 0;
     mSlots[slotIndex].mFence = Fence::NO_FENCE;
     mSlots[slotIndex].mFrameNumber = 0;
 }
 // Used for refactoring, should not be in final interface
 sp<GonkBufferQueue> GonkConsumerBase::getBufferQueue() const {
     Mutex::Autolock lock(mMutex);
     return mConsumer;
 }
 void GonkConsumerBase::onFrameAvailable() {
     CB_LOGV("onFrameAvailable");
     sp<FrameAvailableListener> listener;
     { // scope for the lock
         Mutex::Autolock lock(mMutex);
         listener = mFrameAvailableListener.promote();
     }
     if (listener != NULL) {
         CB_LOGV("actually calling onFrameAvailable");
         listener->onFrameAvailable();
     }
 }
 void GonkConsumerBase::onBuffersReleased() {
     Mutex::Autolock lock(mMutex);
     CB_LOGV("onBuffersReleased");
     if (mAbandoned) {
         // Nothing to do if we're already abandoned.
         return;
     }
     uint32_t mask = 0;
     mConsumer->getReleasedBuffers(&mask);
     for (int i = 0; i < GonkBufferQueue::NUM_BUFFER_SLOTS; i++) {
         if (mask & (1 << i)) {
             freeBufferLocked(i);
         }
     }
 }
 void GonkConsumerBase::abandon() {
     CB_LOGV("abandon");
     Mutex::Autolock lock(mMutex);
     if (!mAbandoned) {
         abandonLocked();
         mAbandoned = true;
     }
 }
 void GonkConsumerBase::abandonLocked() {
 	CB_LOGV("abandonLocked");
     for (int i =0; i < GonkBufferQueue::NUM_BUFFER_SLOTS; i++) {
         freeBufferLocked(i);
     }
     // disconnect from the BufferQueue
     mConsumer->consumerDisconnect();
     mConsumer.clear();
 }
 void GonkConsumerBase::setFrameAvailableListener(
         const wp<FrameAvailableListener>& listener) {
     CB_LOGV("setFrameAvailableListener");
     Mutex::Autolock lock(mMutex);
     mFrameAvailableListener = listener;
 }
 void GonkConsumerBase::dump(String8& result) const {
     dump(result, "");
 }
 void GonkConsumerBase::dump(String8& result, const char* prefix) const {
     Mutex::Autolock _l(mMutex);
     dumpLocked(result, prefix);
 }
 void GonkConsumerBase::dumpLocked(String8& result, const char* prefix) const {
     result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
     if (!mAbandoned) {
         mConsumer->dump(result, prefix);
     }
 }
 status_t GonkConsumerBase::acquireBufferLocked(IGonkGraphicBufferConsumer::BufferItem *item,
         nsecs_t presentWhen) {
     status_t err = mConsumer->acquireBuffer(item, presentWhen);
     if (err != NO_ERROR) {
         return err;
     }
     if (item->mGraphicBuffer != NULL) {
         mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer;
     }
     mSlots[item->mBuf].mFrameNumber = item->mFrameNumber;
     mSlots[item->mBuf].mFence = item->mFence;
     CB_LOGV("acquireBufferLocked: -> slot=%d", item->mBuf);
     return OK;
 }
 status_t GonkConsumerBase::addReleaseFence(int slot,
         const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
     Mutex::Autolock lock(mMutex);
     return addReleaseFenceLocked(slot, graphicBuffer, fence);
 }
 status_t GonkConsumerBase::addReleaseFenceLocked(int slot,
         const sp<GraphicBuffer> graphicBuffer, const sp<Fence>& fence) {
     CB_LOGV("addReleaseFenceLocked: slot=%d", slot);
     // If consumer no longer tracks this graphicBuffer, we can safely
     // drop this fence, as it will never be received by the producer.
     if (!stillTracking(slot, graphicBuffer)) {
         return OK;
     }
     if (!mSlots[slot].mFence.get()) {
         mSlots[slot].mFence = fence;
     } else {
         sp<Fence> mergedFence = Fence::merge(
                 String8::format("%.28s:%d", mName.string(), slot),
                 mSlots[slot].mFence, fence);
         if (!mergedFence.get()) {
             CB_LOGE("failed to merge release fences");
             // synchronization is broken, the best we can do is hope fences
             // signal in order so the new fence will act like a union
             mSlots[slot].mFence = fence;
             return BAD_VALUE;
         }
         mSlots[slot].mFence = mergedFence;
     }
     return OK;
 }
 status_t GonkConsumerBase::releaseBufferLocked(int slot, const sp<GraphicBuffer> graphicBuffer) {
     // If consumer no longer tracks this graphicBuffer (we received a new
     // buffer on the same slot), the buffer producer is definitely no longer
     // tracking it.
     if (!stillTracking(slot, graphicBuffer)) {
         return OK;
     }
     CB_LOGV("releaseBufferLocked: slot=%d/%llu",
             slot, mSlots[slot].mFrameNumber);
     status_t err = mConsumer->releaseBuffer(slot, mSlots[slot].mFrameNumber, mSlots[slot].mFence);
     if (err == GonkBufferQueue::STALE_BUFFER_SLOT) {
         freeBufferLocked(slot);
     }
     mSlots[slot].mFence = Fence::NO_FENCE;
     return err;
 }
 bool GonkConsumerBase::stillTracking(int slot,
         const sp<GraphicBuffer> graphicBuffer) {
     if (slot < 0 || slot >= GonkBufferQueue::NUM_BUFFER_SLOTS) {
         return false;
     }
     return (mSlots[slot].mGraphicBuffer != NULL &&
             mSlots[slot].mGraphicBuffer->handle == graphicBuffer->handle);
 }
 } // namespace android

The Tor Browser / annotate

widget/gonk/nativewindow/GonkConsumerBaseKK.cpp@b8a032363ba2 (annotated)

widget/gonk/nativewindow/GonkConsumerBaseKK.cpp