void nsWindow::BringToTop() { if (!sTopWindows.IsEmpty()) { if (nsIWidgetListener* listener = sTopWindows[0]->GetWidgetListener()) listener->WindowDeactivated(); } sTopWindows.RemoveElement(this); sTopWindows.InsertElementAt(0, this); if (mWidgetListener) mWidgetListener->WindowActivated(); Invalidate(sVirtualBounds); }
void nsWindow::BringToTop() { if (!sTopWindows.IsEmpty()) { nsGUIEvent event(true, NS_DEACTIVATE, sTopWindows[0]); (*mEventCallback)(&event); } sTopWindows.RemoveElement(this); sTopWindows.InsertElementAt(0, this); nsGUIEvent event(true, NS_ACTIVATE, this); (*mEventCallback)(&event); Invalidate(sVirtualBounds); }
nsresult ICameraControl::GetListOfCameras(nsTArray<nsString>& aList) { int32_t count = android::Camera::getNumberOfCameras(); DOM_CAMERA_LOGI("getListOfCameras : getNumberOfCameras() returned %d\n", count); if (count <= 0) { aList.Clear(); return NS_OK; } // Allocate 2 extra slots to reserve space for 'front' and 'back' cameras // at the front of the array--we will collapse any empty slots below. aList.SetLength(2); uint32_t extraIdx = 2; bool gotFront = false; bool gotBack = false; while (count--) { nsCString cameraName; nsresult result = GetCameraName(count, cameraName); if (result != NS_OK) { continue; } // The first camera we find named 'back' gets slot 0; and the first // we find named 'front' gets slot 1. All others appear after these. if (cameraName.EqualsLiteral("back")) { CopyUTF8toUTF16(cameraName, aList[0]); gotBack = true; } else if (cameraName.EqualsLiteral("front")) { CopyUTF8toUTF16(cameraName, aList[1]); gotFront = true; } else { CopyUTF8toUTF16(cameraName, *aList.InsertElementAt(extraIdx)); extraIdx++; } } if (!gotFront) { aList.RemoveElementAt(1); } if (!gotBack) { aList.RemoveElementAt(0); } return NS_OK; }
nsresult txStylesheet::addStripSpace( txStripSpaceItem* aStripSpaceItem, nsTArray<txStripSpaceTest*>& aFrameStripSpaceTests) { int32_t testCount = aStripSpaceItem->mStripSpaceTests.Length(); for (; testCount > 0; --testCount) { txStripSpaceTest* sst = aStripSpaceItem->mStripSpaceTests[testCount - 1]; double priority = sst->getDefaultPriority(); int32_t i, frameCount = aFrameStripSpaceTests.Length(); for (i = 0; i < frameCount; ++i) { if (aFrameStripSpaceTests[i]->getDefaultPriority() < priority) { break; } } if (!aFrameStripSpaceTests.InsertElementAt(i, sst)) { return NS_ERROR_OUT_OF_MEMORY; } aStripSpaceItem->mStripSpaceTests.RemoveElementAt(testCount - 1); } return NS_OK; }
void WebMBufferedParser::Append(const unsigned char* aBuffer, uint32_t aLength, nsTArray<WebMTimeDataOffset>& aMapping, ReentrantMonitor& aReentrantMonitor) { static const uint32_t EBML_ID = 0x1a45dfa3; static const uint32_t SEGMENT_ID = 0x18538067; static const uint32_t SEGINFO_ID = 0x1549a966; static const uint32_t TRACKS_ID = 0x1654AE6B; static const uint32_t CLUSTER_ID = 0x1f43b675; static const uint32_t TIMECODESCALE_ID = 0x2ad7b1; static const unsigned char TIMECODE_ID = 0xe7; static const unsigned char BLOCK_ID = 0xa1; static const unsigned char SIMPLEBLOCK_ID = 0xa3; static const uint32_t BLOCK_TIMECODE_LENGTH = 2; static const unsigned char CLUSTER_SYNC_ID[] = { 0x1f, 0x43, 0xb6, 0x75 }; const unsigned char* p = aBuffer; // Parse each byte in aBuffer one-by-one, producing timecodes and updating // aMapping as we go. Parser pauses at end of stream (which may be at any // point within the parse) and resumes parsing the next time Append is // called with new data. while (p < aBuffer + aLength) { switch (mState) { case READ_ELEMENT_ID: mVIntRaw = true; mState = READ_VINT; mNextState = READ_ELEMENT_SIZE; break; case READ_ELEMENT_SIZE: mVIntRaw = false; mElement.mID = mVInt; mState = READ_VINT; mNextState = PARSE_ELEMENT; break; case FIND_CLUSTER_SYNC: if (*p++ == CLUSTER_SYNC_ID[mClusterSyncPos]) { mClusterSyncPos += 1; } else { mClusterSyncPos = 0; } if (mClusterSyncPos == sizeof(CLUSTER_SYNC_ID)) { mVInt.mValue = CLUSTER_ID; mVInt.mLength = sizeof(CLUSTER_SYNC_ID); mState = READ_ELEMENT_SIZE; } break; case PARSE_ELEMENT: mElement.mSize = mVInt; switch (mElement.mID.mValue) { case SEGMENT_ID: mState = READ_ELEMENT_ID; break; case SEGINFO_ID: mGotTimecodeScale = true; mState = READ_ELEMENT_ID; break; case TIMECODE_ID: mVInt = VInt(); mVIntLeft = mElement.mSize.mValue; mState = READ_VINT_REST; mNextState = READ_CLUSTER_TIMECODE; break; case TIMECODESCALE_ID: mVInt = VInt(); mVIntLeft = mElement.mSize.mValue; mState = READ_VINT_REST; mNextState = READ_TIMECODESCALE; break; case CLUSTER_ID: mClusterOffset = mCurrentOffset + (p - aBuffer) - (mElement.mID.mLength + mElement.mSize.mLength); // Handle "unknown" length; if (mElement.mSize.mValue + 1 != uint64_t(1) << (mElement.mSize.mLength * 7)) { mClusterEndOffset = mClusterOffset + mElement.mID.mLength + mElement.mSize.mLength + mElement.mSize.mValue; } else { mClusterEndOffset = -1; } mState = READ_ELEMENT_ID; break; case SIMPLEBLOCK_ID: /* FALLTHROUGH */ case BLOCK_ID: mBlockSize = mElement.mSize.mValue; mBlockTimecode = 0; mBlockTimecodeLength = BLOCK_TIMECODE_LENGTH; mBlockOffset = mCurrentOffset + (p - aBuffer) - (mElement.mID.mLength + mElement.mSize.mLength); mState = READ_VINT; mNextState = READ_BLOCK_TIMECODE; break; case TRACKS_ID: mSkipBytes = mElement.mSize.mValue; mState = CHECK_INIT_FOUND; break; case EBML_ID: mLastInitStartOffset = mCurrentOffset + (p - aBuffer) - (mElement.mID.mLength + mElement.mSize.mLength); /* FALLTHROUGH */ default: mSkipBytes = mElement.mSize.mValue; mState = SKIP_DATA; mNextState = READ_ELEMENT_ID; break; } break; case READ_VINT: { unsigned char c = *p++; uint32_t mask; mVInt.mLength = VIntLength(c, &mask); mVIntLeft = mVInt.mLength - 1; mVInt.mValue = mVIntRaw ? c : c & ~mask; mState = READ_VINT_REST; break; } case READ_VINT_REST: if (mVIntLeft) { mVInt.mValue <<= 8; mVInt.mValue |= *p++; mVIntLeft -= 1; } else { mState = mNextState; } break; case READ_TIMECODESCALE: MOZ_ASSERT(mGotTimecodeScale); mTimecodeScale = mVInt.mValue; mState = READ_ELEMENT_ID; break; case READ_CLUSTER_TIMECODE: mClusterTimecode = mVInt.mValue; mState = READ_ELEMENT_ID; break; case READ_BLOCK_TIMECODE: if (mBlockTimecodeLength) { mBlockTimecode <<= 8; mBlockTimecode |= *p++; mBlockTimecodeLength -= 1; } else { // It's possible we've parsed this data before, so avoid inserting // duplicate WebMTimeDataOffset entries. { ReentrantMonitorAutoEnter mon(aReentrantMonitor); int64_t endOffset = mBlockOffset + mBlockSize + mElement.mID.mLength + mElement.mSize.mLength; uint32_t idx = aMapping.IndexOfFirstElementGt(endOffset); if (idx == 0 || aMapping[idx - 1] != endOffset) { // Don't insert invalid negative timecodes. if (mBlockTimecode >= 0 || mClusterTimecode >= uint16_t(abs(mBlockTimecode))) { MOZ_ASSERT(mGotTimecodeScale); uint64_t absTimecode = mClusterTimecode + mBlockTimecode; absTimecode *= mTimecodeScale; WebMTimeDataOffset entry(endOffset, absTimecode, mLastInitStartOffset, mClusterOffset, mClusterEndOffset); aMapping.InsertElementAt(idx, entry); } } } // Skip rest of block header and the block's payload. mBlockSize -= mVInt.mLength; mBlockSize -= BLOCK_TIMECODE_LENGTH; mSkipBytes = uint32_t(mBlockSize); mState = SKIP_DATA; mNextState = READ_ELEMENT_ID; } break; case SKIP_DATA: if (mSkipBytes) { uint32_t left = aLength - (p - aBuffer); left = std::min(left, mSkipBytes); p += left; mSkipBytes -= left; } if (!mSkipBytes) { mBlockEndOffset = mCurrentOffset + (p - aBuffer); mState = mNextState; } break; case CHECK_INIT_FOUND: if (mSkipBytes) { uint32_t left = aLength - (p - aBuffer); left = std::min(left, mSkipBytes); p += left; mSkipBytes -= left; } if (!mSkipBytes) { if (mInitEndOffset < 0) { mInitEndOffset = mCurrentOffset + (p - aBuffer); mBlockEndOffset = mCurrentOffset + (p - aBuffer); } mState = READ_ELEMENT_ID; } break; } } NS_ASSERTION(p == aBuffer + aLength, "Must have parsed to end of data."); mCurrentOffset += aLength; }
void nsWebMBufferedParser::Append(const unsigned char* aBuffer, uint32_t aLength, nsTArray<nsWebMTimeDataOffset>& aMapping, ReentrantMonitor& aReentrantMonitor) { static const unsigned char CLUSTER_ID[] = { 0x1f, 0x43, 0xb6, 0x75 }; static const unsigned char TIMECODE_ID = 0xe7; static const unsigned char BLOCKGROUP_ID = 0xa0; static const unsigned char BLOCK_ID = 0xa1; static const unsigned char SIMPLEBLOCK_ID = 0xa3; const unsigned char* p = aBuffer; // Parse each byte in aBuffer one-by-one, producing timecodes and updating // aMapping as we go. Parser pauses at end of stream (which may be at any // point within the parse) and resumes parsing the next time Append is // called with new data. while (p < aBuffer + aLength) { switch (mState) { case CLUSTER_SYNC: if (*p++ == CLUSTER_ID[mClusterIDPos]) { mClusterIDPos += 1; } else { mClusterIDPos = 0; } // Cluster ID found, it's likely this is a valid sync point. If this // is a spurious match, the later parse steps will encounter an error // and return to CLUSTER_SYNC. if (mClusterIDPos == sizeof(CLUSTER_ID)) { mClusterIDPos = 0; mState = READ_VINT; mNextState = TIMECODE_SYNC; } break; case READ_VINT: { unsigned char c = *p++; uint32_t mask; mVIntLength = VIntLength(c, &mask); mVIntLeft = mVIntLength - 1; mVInt = c & ~mask; mState = READ_VINT_REST; break; } case READ_VINT_REST: if (mVIntLeft) { mVInt <<= 8; mVInt |= *p++; mVIntLeft -= 1; } else { mState = mNextState; } break; case TIMECODE_SYNC: if (*p++ != TIMECODE_ID) { p -= 1; mState = CLUSTER_SYNC; break; } mClusterTimecode = 0; mState = READ_VINT; mNextState = READ_CLUSTER_TIMECODE; break; case READ_CLUSTER_TIMECODE: if (mVInt) { mClusterTimecode <<= 8; mClusterTimecode |= *p++; mVInt -= 1; } else { mState = ANY_BLOCK_SYNC; } break; case ANY_BLOCK_SYNC: { unsigned char c = *p++; if (c == BLOCKGROUP_ID) { mState = READ_VINT; mNextState = ANY_BLOCK_SYNC; } else if (c == SIMPLEBLOCK_ID || c == BLOCK_ID) { mBlockOffset = mCurrentOffset + (p - aBuffer) - 1; mState = READ_VINT; mNextState = READ_BLOCK; } else { uint32_t length = VIntLength(c, nullptr); if (length == 4) { p -= 1; mState = CLUSTER_SYNC; } else { mState = READ_VINT; mNextState = SKIP_ELEMENT; } } break; } case READ_BLOCK: mBlockSize = mVInt; mBlockTimecode = 0; mBlockTimecodeLength = 2; mState = READ_VINT; mNextState = READ_BLOCK_TIMECODE; break; case READ_BLOCK_TIMECODE: if (mBlockTimecodeLength) { mBlockTimecode <<= 8; mBlockTimecode |= *p++; mBlockTimecodeLength -= 1; } else { // It's possible we've parsed this data before, so avoid inserting // duplicate nsWebMTimeDataOffset entries. { ReentrantMonitorAutoEnter mon(aReentrantMonitor); uint32_t idx; if (!aMapping.GreatestIndexLtEq(mBlockOffset, idx)) { nsWebMTimeDataOffset entry(mBlockOffset, mClusterTimecode + mBlockTimecode); aMapping.InsertElementAt(idx, entry); } } // Skip rest of block header and the block's payload. mBlockSize -= mVIntLength; mBlockSize -= 2; mSkipBytes = uint32_t(mBlockSize); mState = SKIP_DATA; mNextState = ANY_BLOCK_SYNC; } break; case SKIP_DATA: if (mSkipBytes) { uint32_t left = aLength - (p - aBuffer); left = NS_MIN(left, mSkipBytes); p += left; mSkipBytes -= left; } else { mState = mNextState; } break; case SKIP_ELEMENT: mSkipBytes = uint32_t(mVInt); mState = SKIP_DATA; mNextState = ANY_BLOCK_SYNC; break; } } NS_ASSERTION(p == aBuffer + aLength, "Must have parsed to end of data."); mCurrentOffset += aLength; }