The Tor Browser: comparison content/media/FileBlockCache.h

--1:000000000000
+:388f278225b1
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef FILE_BLOCK_CACHE_H_
+#define FILE_BLOCK_CACHE_H_
+#include "mozilla/Attributes.h"
+#include "mozilla/Monitor.h"
+#include "nsTArray.h"
+#include "MediaCache.h"
+#include "nsDeque.h"
+#include "nsThreadUtils.h"
+struct PRFileDesc;
+namespace mozilla {
+// Manages file I/O for the media cache. Data comes in over the network
+// via callbacks on the main thread, however we don't want to write the
+// incoming data to the media cache on the main thread, as this could block
+// causing UI jank.
+//
+// So FileBlockCache provides an abstraction for a temporary file accessible
+// as an array of blocks, which supports a block move operation, and
+// allows synchronous reading and writing from any thread, with writes being
+// buffered so as not to block.
+//
+// Writes and cache block moves (which require reading) are deferred to
+// their own non-main thread. This object also ensures that data which has
+// been scheduled to be written, but hasn't actually *been* written, is read
+// as if it had, i.e. pending writes are cached in readable memory until
+// they're flushed to file.
+//
+// To improve efficiency, writes can only be done at block granularity,
+// whereas reads can be done with byte granularity.
+//
+// Note it's also recommended not to read from the media cache from the main
+// thread to prevent jank.
+//
+// When WriteBlock() or MoveBlock() are called, data about how to complete
+// the block change is added to mBlockChanges, indexed by block index, and
+// the block index is appended to the mChangeIndexList. This enables
+// us to quickly tell if a block has been changed, and ensures we can perform
+// the changes in the correct order. An event is dispatched to perform the
+// changes listed in mBlockChanges to file. Read() checks mBlockChanges and
+// determines the current data to return, reading from file or from
+// mBlockChanges as necessary.
+class FileBlockCache : public nsRunnable {
+public:
+enum {
+BLOCK_SIZE = MediaCacheStream::BLOCK_SIZE
+};
+FileBlockCache();
+~FileBlockCache();
+// Assumes ownership of aFD.
+nsresult Open(PRFileDesc* aFD);
+// Closes writer, shuts down thread.
+void Close();
+// Can be called on any thread. This defers to a non-main thread.
+nsresult WriteBlock(uint32_t aBlockIndex, const uint8_t* aData);
+// Performs block writes and block moves on its own thread.
+NS_IMETHOD Run() MOZ_OVERRIDE;
+// Synchronously reads data from file. May read from file or memory
+// depending on whether written blocks have been flushed to file yet.
+// Not recommended to be called from the main thread, as can cause jank.
+nsresult Read(int64_t aOffset,
+uint8_t* aData,
+int32_t aLength,
+int32_t* aBytes);
+// Moves a block asynchronously. Can be called on any thread.
+// This defers file I/O to a non-main thread.
+nsresult MoveBlock(int32_t aSourceBlockIndex, int32_t aDestBlockIndex);
+// Represents a change yet to be made to a block in the file. The change
+// is either a write (and the data to be written is stored in this struct)
+// or a move (and the index of the source block is stored instead).
+struct BlockChange MOZ_FINAL {
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BlockChange)
+// This block is waiting in memory to be written.
+// Stores a copy of the block, so we can write it asynchronously.
+BlockChange(const uint8_t* aData)
+: mSourceBlockIndex(-1)
+{
+mData = new uint8_t[BLOCK_SIZE];
+memcpy(mData.get(), aData, BLOCK_SIZE);
+}
+// This block's contents are located in another file
+// block, i.e. this block has been moved.
+BlockChange(int32_t aSourceBlockIndex)
+: mSourceBlockIndex(aSourceBlockIndex) {}
+nsAutoArrayPtr<uint8_t> mData;
+const int32_t mSourceBlockIndex;
+bool IsMove() const {
+return mSourceBlockIndex != -1;
+}
+bool IsWrite() const {
+return mSourceBlockIndex == -1 &&
+mData.get() != nullptr;
+}
+private:
+// Private destructor, to discourage deletion outside of Release():
+~BlockChange()
+{
+}
+};
+class Int32Queue : private nsDeque {
+public:
+int32_t PopFront() {
+int32_t front = ObjectAt(0);
+nsDeque::PopFront();
+return front;
+}
+void PushBack(int32_t aValue) {
+nsDeque::Push(reinterpret_cast<void*>(aValue));
+}
+bool Contains(int32_t aValue) {
+for (int32_t i = 0; i < GetSize(); ++i) {
+if (ObjectAt(i) == aValue) {
+return true;
+}
+}
+return false;
+}
+bool IsEmpty() {
+return nsDeque::GetSize() == 0;
+}
+private:
+int32_t ObjectAt(int32_t aIndex) {
+void* v = nsDeque::ObjectAt(aIndex);
+return reinterpret_cast<uintptr_t>(v);
+}
+};
+private:
+int64_t BlockIndexToOffset(int32_t aBlockIndex) {
+return static_cast<int64_t>(aBlockIndex) * BLOCK_SIZE;
+}
+// Monitor which controls access to mFD and mFDCurrentPos. Don't hold
+// mDataMonitor while holding mFileMonitor! mFileMonitor must be owned
+// while accessing any of the following data fields or methods.
+Monitor mFileMonitor;
+// Moves a block already committed to file.
+nsresult MoveBlockInFile(int32_t aSourceBlockIndex,
+int32_t aDestBlockIndex);
+// Seeks file pointer.
+nsresult Seek(int64_t aOffset);
+// Reads data from file offset.
+nsresult ReadFromFile(int64_t aOffset,
+uint8_t* aDest,
+int32_t aBytesToRead,
+int32_t& aBytesRead);
+nsresult WriteBlockToFile(int32_t aBlockIndex, const uint8_t* aBlockData);
+// File descriptor we're writing to. This is created externally, but
+// shutdown by us.
+PRFileDesc* mFD;
+// The current file offset in the file.
+int64_t mFDCurrentPos;
+// Monitor which controls access to all data in this class, except mFD
+// and mFDCurrentPos. Don't hold mDataMonitor while holding mFileMonitor!
+// mDataMonitor must be owned while accessing any of the following data
+// fields or methods.
+Monitor mDataMonitor;
+// Ensures we either are running the event to preform IO, or an event
+// has been dispatched to preform the IO.
+// mDataMonitor must be owned while calling this.
+void EnsureWriteScheduled();
+// Array of block changes to made. If mBlockChanges[offset/BLOCK_SIZE] == nullptr,
+// then the block has no pending changes to be written, but if
+// mBlockChanges[offset/BLOCK_SIZE] != nullptr, then either there's a block
+// cached in memory waiting to be written, or this block is the target of a
+// block move.
+nsTArray< nsRefPtr<BlockChange> > mBlockChanges;
+// Thread upon which block writes and block moves are performed. This is
+// created upon open, and shutdown (asynchronously) upon close (on the
+// main thread).
+nsCOMPtr<nsIThread> mThread;
+// Queue of pending block indexes that need to be written or moved.
+//nsAutoTArray<int32_t, 8> mChangeIndexList;
+Int32Queue mChangeIndexList;
+// True if we've dispatched an event to commit all pending block changes
+// to file on mThread.
+bool mIsWriteScheduled;
+// True if the writer is ready to write data to file.
+bool mIsOpen;
+};
+} // End namespace mozilla.
+#endif /* FILE_BLOCK_CACHE_H_ */

The Tor Browser / file comparison

comparison: content/media/FileBlockCache.h

content/media/FileBlockCache.h