gecko-dev/dom/file/MemoryBlobImpl.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 mozilla_dom_MemoryBlobImpl_h
#define mozilla_dom_MemoryBlobImpl_h

#include "mozilla/dom/BaseBlobImpl.h"
#include "mozilla/LinkedList.h"
#include "mozilla/StaticMutex.h"
#include "mozilla/StaticPtr.h"
#include "nsICloneableInputStream.h"
#include "nsIInputStream.h"
#include "nsIIPCSerializableInputStream.h"
#include "nsIMemoryReporter.h"
#include "nsISeekableStream.h"

namespace mozilla {
namespace dom {

class MemoryBlobImpl final : public BaseBlobImpl {
 public:
  NS_INLINE_DECL_REFCOUNTING_INHERITED(MemoryBlobImpl, BaseBlobImpl)

  MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength, const nsAString& aName,
                 const nsAString& aContentType, int64_t aLastModifiedDate)
      : BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aName, aContentType,
                     aLength, aLastModifiedDate),
        mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
    MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
  }

  MemoryBlobImpl(void* aMemoryBuffer, uint64_t aLength,
                 const nsAString& aContentType)
      : BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aContentType,
                     aLength),
        mDataOwner(new DataOwner(aMemoryBuffer, aLength)) {
    MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
  }

  virtual void CreateInputStream(nsIInputStream** aStream,
                                 ErrorResult& aRv) override;

  virtual already_AddRefed<BlobImpl> CreateSlice(uint64_t aStart,
                                                 uint64_t aLength,
                                                 const nsAString& aContentType,
                                                 ErrorResult& aRv) override;

  virtual bool IsMemoryFile() const override { return true; }

  size_t GetAllocationSize() const override { return mLength; }

  size_t GetAllocationSize(
      FallibleTArray<BlobImpl*>& aVisitedBlobImpls) const override {
    return GetAllocationSize();
  }

  class DataOwner final : public mozilla::LinkedListElement<DataOwner> {
   public:
    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DataOwner)
    DataOwner(void* aMemoryBuffer, uint64_t aLength)
        : mData(aMemoryBuffer), mLength(aLength) {
      mozilla::StaticMutexAutoLock lock(sDataOwnerMutex);

      if (!sDataOwners) {
        sDataOwners = new mozilla::LinkedList<DataOwner>();
        EnsureMemoryReporterRegistered();
      }
      sDataOwners->insertBack(this);
    }

   private:
    // Private destructor, to discourage deletion outside of Release():
    ~DataOwner() {
      mozilla::StaticMutexAutoLock lock(sDataOwnerMutex);

      remove();
      if (sDataOwners->isEmpty()) {
        // Free the linked list if it's empty.
        sDataOwners = nullptr;
      }

      free(mData);
    }

   public:
    static void EnsureMemoryReporterRegistered();

    // sDataOwners and sMemoryReporterRegistered may only be accessed while
    // holding sDataOwnerMutex!  You also must hold the mutex while touching
    // elements of the linked list that DataOwner inherits from.
    static mozilla::StaticMutex sDataOwnerMutex;
    static mozilla::StaticAutoPtr<mozilla::LinkedList<DataOwner> > sDataOwners;
    static bool sMemoryReporterRegistered;

    void* mData;
    uint64_t mLength;
  };

  class DataOwnerAdapter final : public nsIInputStream,
                                 public nsISeekableStream,
                                 public nsIIPCSerializableInputStream,
                                 public nsICloneableInputStream {
    typedef MemoryBlobImpl::DataOwner DataOwner;

   public:
    static nsresult Create(DataOwner* aDataOwner, uint32_t aStart,
                           uint32_t aLength, nsIInputStream** _retval);

    NS_DECL_THREADSAFE_ISUPPORTS

    // These are mandatory.
    NS_FORWARD_NSIINPUTSTREAM(mStream->)
    NS_FORWARD_NSISEEKABLESTREAM(mSeekableStream->)
    NS_FORWARD_NSITELLABLESTREAM(mSeekableStream->)
    NS_FORWARD_NSICLONEABLEINPUTSTREAM(mCloneableInputStream->)

    // This is optional. We use a conditional QI to keep it from being called
    // if the underlying stream doesn't support it.
    NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(mSerializableInputStream->)

   private:
    ~DataOwnerAdapter() {}

    DataOwnerAdapter(DataOwner* aDataOwner, nsIInputStream* aStream)
        : mDataOwner(aDataOwner),
          mStream(aStream),
          mSeekableStream(do_QueryInterface(aStream)),
          mSerializableInputStream(do_QueryInterface(aStream)),
          mCloneableInputStream(do_QueryInterface(aStream)) {
      MOZ_ASSERT(mSeekableStream, "Somebody gave us the wrong stream!");
    }

    RefPtr<DataOwner> mDataOwner;
    nsCOMPtr<nsIInputStream> mStream;
    nsCOMPtr<nsISeekableStream> mSeekableStream;
    nsCOMPtr<nsIIPCSerializableInputStream> mSerializableInputStream;
    nsCOMPtr<nsICloneableInputStream> mCloneableInputStream;
  };

 private:
  // Create slice
  MemoryBlobImpl(const MemoryBlobImpl* aOther, uint64_t aStart,
                 uint64_t aLength, const nsAString& aContentType)
      : BaseBlobImpl(NS_LITERAL_STRING("MemoryBlobImpl"), aContentType,
                     aOther->mStart + aStart, aLength),
        mDataOwner(aOther->mDataOwner) {
    MOZ_ASSERT(mDataOwner && mDataOwner->mData, "must have data");
    mImmutable = aOther->mImmutable;
  }

  ~MemoryBlobImpl() {}

  // Used when backed by a memory store
  RefPtr<DataOwner> mDataOwner;
};

}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_MemoryBlobImpl_h