Make sure we don't trigger a log warning if calling ALooper::stop() from the looper thread.

struct ALooper::LooperThread : public Thread {

struct ALooper::LooperThread : public Thread {

    LooperThread(ALooper *looper, bool canCallJava)

    LooperThread(ALooper *looper, bool canCallJava)

        : Thread(canCallJava),

        : Thread(canCallJava),

          mLooper(looper) {

          mLooper(looper),

          mThreadId(NULL) {

    }

    virtual status_t readyToRun() {

        mThreadId = androidGetThreadId();

        return Thread::readyToRun();

    }

    }

    virtual bool threadLoop() {

    virtual bool threadLoop() {

        return mLooper->loop();

        return mLooper->loop();

    }

    }

    bool isCurrentThread() const {

        return mThreadId == androidGetThreadId();

    }

protected:

protected:

    virtual ~LooperThread() {}

    virtual ~LooperThread() {}

private:

private:

    ALooper *mLooper;

    ALooper *mLooper;

    android_thread_id_t mThreadId;

    DISALLOW_EVIL_CONSTRUCTORS(LooperThread);

    DISALLOW_EVIL_CONSTRUCTORS(LooperThread);

};

};

    mQueueChangedCondition.signal();

    mQueueChangedCondition.signal();

    if (!runningLocally) {

    if (!runningLocally && !thread->isCurrentThread()) {

        // If not running locally and this thread _is_ the looper thread,

        // the loop() function will return and never be called again.

        thread->requestExitAndWait();

        thread->requestExitAndWait();

    }

    }

    gLooperRoster.deliverMessage(event.mMessage);

    gLooperRoster.deliverMessage(event.mMessage);

    // NOTE: It's important to note that at this point our "ALooper" object

    // may no longer exist (its final reference may have gone away while

    // delivering the message). We have made sure, however, that loop()

    // won't be called again.

    return true;

    return true;

}

}