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_DECL_ISUPPORTS_INHERITED

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

  virtual void GetInternalStream(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;
  }

  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_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(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