DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (1aeaa33a64f9)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
/* -*- 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_SOURCEBUFFERRESOURCE_H_
#define MOZILLA_SOURCEBUFFERRESOURCE_H_

#include "mozilla/AbstractThread.h"
#include "mozilla/Logging.h"
#include "MediaResource.h"
#include "nsIPrincipal.h"
#include "ResourceQueue.h"

#define UNIMPLEMENTED()                               \
  { /* Logging this is too spammy to do by default */ \
  }

namespace mozilla {

class MediaByteBuffer;
class TaskQueue;

namespace dom {

class SourceBuffer;

}  // namespace dom

DDLoggedTypeDeclNameAndBase(SourceBufferResource, MediaResource);

// SourceBufferResource is not thread safe.
class SourceBufferResource final
    : public MediaResource,
      public DecoderDoctorLifeLogger<SourceBufferResource> {
 public:
  SourceBufferResource();
  nsresult Close() override;
  nsresult ReadAt(int64_t aOffset, char* aBuffer, uint32_t aCount,
                  uint32_t* aBytes) override;
  // Memory-based and no locks, caching discouraged.
  bool ShouldCacheReads() override { return false; }
  void Pin() override { UNIMPLEMENTED(); }
  void Unpin() override { UNIMPLEMENTED(); }
  int64_t GetLength() override { return mInputBuffer.GetLength(); }
  int64_t GetNextCachedData(int64_t aOffset) override {
    MOZ_ASSERT(OnTaskQueue());
    MOZ_ASSERT(aOffset >= 0);
    if (uint64_t(aOffset) < mInputBuffer.GetOffset()) {
      return mInputBuffer.GetOffset();
    } else if (aOffset == GetLength()) {
      return -1;
    }
    return aOffset;
  }
  int64_t GetCachedDataEnd(int64_t aOffset) override {
    MOZ_ASSERT(OnTaskQueue());
    MOZ_ASSERT(aOffset >= 0);
    if (uint64_t(aOffset) < mInputBuffer.GetOffset() ||
        aOffset >= GetLength()) {
      // aOffset is outside of the buffered range.
      return aOffset;
    }
    return GetLength();
  }
  bool IsDataCachedToEndOfResource(int64_t aOffset) override { return false; }
  nsresult ReadFromCache(char* aBuffer, int64_t aOffset,
                         uint32_t aCount) override;

  nsresult GetCachedRanges(MediaByteRangeSet& aRanges) override {
    MOZ_ASSERT(OnTaskQueue());
    if (mInputBuffer.GetLength()) {
      aRanges +=
          MediaByteRange(mInputBuffer.GetOffset(), mInputBuffer.GetLength());
    }
    return NS_OK;
  }

  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
    MOZ_ASSERT(OnTaskQueue());
    return mInputBuffer.SizeOfExcludingThis(aMallocSizeOf);
  }

  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
  }

  // Used by SourceBuffer.
  void AppendData(MediaByteBuffer* aData);
  void Ended();
  bool IsEnded() {
    MOZ_ASSERT(OnTaskQueue());
    return mEnded;
  }
  // Remove data from resource if it holds more than the threshold reduced by
  // the given number of bytes. Returns amount evicted.
  uint32_t EvictData(uint64_t aPlaybackOffset, int64_t aThresholdReduct,
                     ErrorResult& aRv);

  // Remove data from resource before the given offset.
  void EvictBefore(uint64_t aOffset, ErrorResult& aRv);

  // Remove all data from the resource
  uint32_t EvictAll();

  // Returns the amount of data currently retained by this resource.
  int64_t GetSize() {
    MOZ_ASSERT(OnTaskQueue());
    return mInputBuffer.GetLength() - mInputBuffer.GetOffset();
  }

#if defined(DEBUG)
  void Dump(const char* aPath) { mInputBuffer.Dump(aPath); }
#endif

 private:
  virtual ~SourceBufferResource();
  nsresult ReadAtInternal(int64_t aOffset, char* aBuffer, uint32_t aCount,
                          uint32_t* aBytes);

#if defined(DEBUG)
  const RefPtr<TaskQueue> mTaskQueue;
  // TaskQueue methods and objects.
  AbstractThread* GetTaskQueue() const;
  bool OnTaskQueue() const;
#endif

  // The buffer holding resource data.
  ResourceQueue mInputBuffer;

  bool mClosed = false;
  bool mEnded = false;
};

}  // namespace mozilla

#undef UNIMPLEMENTED

#endif /* MOZILLA_SOURCEBUFFERRESOURCE_H_ */