Backed out changeset 46b6cb002a34 (bug 1036849) for leaks on a CLOSED TREE
authorWes Kocher <wkocher@mozilla.com>
Mon, 17 Nov 2014 17:16:25 -0800
changeset 240496 1779f503ab02cc05bddfe2738027b2e99c1c147f
parent 240495 80d8ee785026329446dc8d1d7390c1481f939d57
child 240497 0edc83d3670fece8cf5a07a45823312cd046ca5d
push id4311
push userraliiev@mozilla.com
push dateMon, 12 Jan 2015 19:37:41 +0000
treeherdermozilla-beta@150c9fed433b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1036849
milestone36.0a1
backs out46b6cb002a3441180fd8f01ce5193016bce1cd64
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset 46b6cb002a34 (bug 1036849) for leaks on a CLOSED TREE
dom/media/MediaDecoderReader.h
dom/media/fmp4/MP4Reader.cpp
dom/media/fmp4/MP4Reader.h
dom/media/fmp4/PlatformDecoderModule.h
dom/media/fmp4/SharedDecoderManager.cpp
dom/media/fmp4/SharedDecoderManager.h
dom/media/fmp4/moz.build
dom/media/mediasource/MediaSourceReader.cpp
dom/media/mediasource/MediaSourceReader.h
--- a/dom/media/MediaDecoderReader.h
+++ b/dom/media/MediaDecoderReader.h
@@ -15,17 +15,16 @@
 namespace mozilla {
 
 namespace dom {
 class TimeRanges;
 }
 
 class RequestSampleCallback;
 class MediaDecoderReader;
-class SharedDecoderManager;
 
 // Encapsulates the decoding and reading of media data. Reading can either
 // synchronous and done on the calling "decode" thread, or asynchronous and
 // performed on a background thread, with the result being returned by
 // callback. Never hold the decoder monitor when calling into this class.
 // Unless otherwise specified, methods and fields of this class can only
 // be accessed on the decode task queue.
 class MediaDecoderReader {
@@ -43,17 +42,16 @@ public:
   // True if this reader is waiting for a Content Decryption Module to become
   // available.
   virtual bool IsWaitingOnCDMResource() { return false; }
   // True when this reader need to become dormant state
   virtual bool IsDormantNeeded() { return false; }
   // Release media resources they should be released in dormant state
   // The reader can be made usable again by calling ReadMetadata().
   virtual void ReleaseMediaResources() {};
-  virtual void SetSharedDecoderManager(SharedDecoderManager* aManager) {}
   // Breaks reference-counted cycles. Called during shutdown.
   // WARNING: If you override this, you must call the base implementation
   // in your override.
   virtual void BreakCycles();
 
   // Destroys the decoding state. The reader cannot be made usable again.
   // This is different from ReleaseMediaResources() as it is irreversable,
   // whereas ReleaseMediaResources() is.
--- a/dom/media/fmp4/MP4Reader.cpp
+++ b/dom/media/fmp4/MP4Reader.cpp
@@ -9,17 +9,16 @@
 #include "nsSize.h"
 #include "VideoUtils.h"
 #include "mozilla/dom/HTMLMediaElement.h"
 #include "ImageContainer.h"
 #include "Layers.h"
 #include "SharedThreadPool.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/TimeRanges.h"
-#include "SharedDecoderManager.h"
 
 #ifdef MOZ_EME
 #include "mozilla/CDMProxy.h"
 #endif
 
 using mozilla::layers::Image;
 using mozilla::layers::LayerManager;
 using mozilla::layers::LayersBackend;
@@ -410,31 +409,22 @@ MP4Reader::ReadMetadata(MediaInfo* aInfo
     nsresult rv = mAudio.mDecoder->Init();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   if (HasVideo()) {
     const VideoDecoderConfig& video = mDemuxer->VideoConfig();
     mInfo.mVideo.mDisplay =
       nsIntSize(video.display_width, video.display_height);
-    mVideo.mCallback = new DecoderCallback(this, kVideo);
-    if (mSharedDecoderManager) {
-      mVideo.mDecoder =
-        mSharedDecoderManager->CreateH264Decoder(video,
-                                                 mLayersBackendType,
-                                                 mDecoder->GetImageContainer(),
-                                                 mVideo.mTaskQueue,
-                                                 mVideo.mCallback);
-    } else {
-      mVideo.mDecoder = mPlatform->CreateH264Decoder(video,
-                                                     mLayersBackendType,
-                                                     mDecoder->GetImageContainer(),
-                                                     mVideo.mTaskQueue,
-                                                     mVideo.mCallback);
-    }
+    mVideo.mCallback = new  DecoderCallback(this, kVideo);
+    mVideo.mDecoder = mPlatform->CreateH264Decoder(video,
+                                                   mLayersBackendType,
+                                                   mDecoder->GetImageContainer(),
+                                                   mVideo.mTaskQueue,
+                                                   mVideo.mCallback);
     NS_ENSURE_TRUE(mVideo.mDecoder != nullptr, NS_ERROR_FAILURE);
     nsresult rv = mVideo.mDecoder->Init();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Get the duration, and report it to the decoder if we have it.
   Microseconds duration = mDemuxer->Duration();
   if (duration != -1) {
@@ -478,16 +468,22 @@ MP4Reader::HasVideo()
 
 MP4Reader::DecoderData&
 MP4Reader::GetDecoderData(TrackType aTrack)
 {
   MOZ_ASSERT(aTrack == kAudio || aTrack == kVideo);
   return (aTrack == kAudio) ? mAudio : mVideo;
 }
 
+MediaDataDecoder*
+MP4Reader::Decoder(TrackType aTrack)
+{
+  return GetDecoderData(aTrack).mDecoder;
+}
+
 MP4Sample*
 MP4Reader::PopSample(TrackType aTrack)
 {
   switch (aTrack) {
     case kAudio:
       return mDemuxer->DemuxAudioSample();
 
     case kVideo:
@@ -883,26 +879,9 @@ void MP4Reader::NotifyResourcesStatusCha
 {
 #ifdef MOZ_GONK_MEDIACODEC
   if (mDecoder) {
     mDecoder->NotifyWaitingForResourcesStatusChanged();
   }
 #endif
 }
 
-void
-MP4Reader::SetIdle()
-{
-  if (mSharedDecoderManager && mVideo.mDecoder) {
-    mSharedDecoderManager->SetIdle(mVideo.mDecoder);
-    NotifyResourcesStatusChanged();
-  }
-}
-
-void
-MP4Reader::SetSharedDecoderManager(SharedDecoderManager* aManager)
-{
-#ifdef MOZ_GONK_MEDIACODEC
-  mSharedDecoderManager = aManager;
-#endif
-}
-
 } // namespace mozilla
--- a/dom/media/fmp4/MP4Reader.h
+++ b/dom/media/fmp4/MP4Reader.h
@@ -57,22 +57,19 @@ public:
   virtual void NotifyDataArrived(const char* aBuffer, uint32_t aLength,
                                  int64_t aOffset) MOZ_OVERRIDE;
 
   virtual int64_t GetEvictionOffset(double aTime) MOZ_OVERRIDE;
 
   virtual nsresult GetBuffered(dom::TimeRanges* aBuffered) MOZ_OVERRIDE;
 
   // For Media Resource Management
-  virtual void SetIdle() MOZ_OVERRIDE;
   virtual bool IsWaitingMediaResources() MOZ_OVERRIDE;
   virtual bool IsDormantNeeded() MOZ_OVERRIDE;
   virtual void ReleaseMediaResources() MOZ_OVERRIDE;
-  virtual void SetSharedDecoderManager(SharedDecoderManager* aManager)
-    MOZ_OVERRIDE;
 
   virtual nsresult ResetDecode() MOZ_OVERRIDE;
 
   virtual void Shutdown() MOZ_OVERRIDE;
 
 private:
 
   void ExtractCryptoInitData(nsTArray<uint8_t>& aInitData);
@@ -177,27 +174,27 @@ private:
 
   // The last number of decoded output frames that we've reported to
   // MediaDecoder::NotifyDecoded(). We diff the number of output video
   // frames every time that DecodeVideoData() is called, and report the
   // delta there.
   uint64_t mLastReportedNumDecodedFrames;
 
   DecoderData& GetDecoderData(mp4_demuxer::TrackType aTrack);
+  MediaDataDecoder* Decoder(mp4_demuxer::TrackType aTrack);
 
   layers::LayersBackend mLayersBackendType;
 
   nsTArray<nsTArray<uint8_t>> mInitDataEncountered;
 
   // True if we've read the streams' metadata.
   bool mDemuxerInitialized;
 
   // Synchronized by decoder monitor.
   bool mIsEncrypted;
 
   bool mIndexReady;
   Monitor mIndexMonitor;
-  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla
 
 #endif
--- a/dom/media/fmp4/PlatformDecoderModule.h
+++ b/dom/media/fmp4/PlatformDecoderModule.h
@@ -225,15 +225,15 @@ public:
 
   // For Codec Resource Management
   virtual bool IsWaitingMediaResources() {
     return false;
   };
   virtual bool IsDormantNeeded() {
     return false;
   };
-  virtual void ReleaseMediaResources() {}
-  virtual void ReleaseDecoder() {}
+  virtual void ReleaseMediaResources() {};
+  virtual void ReleaseDecoder() {};
 };
 
 } // namespace mozilla
 
 #endif
deleted file mode 100644
--- a/dom/media/fmp4/SharedDecoderManager.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-/* -*- 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/. */
-
-#include "SharedDecoderManager.h"
-#include "mp4_demuxer/DecoderData.h"
-
-namespace mozilla {
-
-class SharedDecoderCallback : public MediaDataDecoderCallback
-{
-public:
-  SharedDecoderCallback(SharedDecoderManager* aManager) : mManager(aManager) {}
-
-  virtual void Output(MediaData* aData) MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->mActiveCallback->Output(aData);
-    }
-  }
-  virtual void Error() MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->mActiveCallback->Error();
-    }
-  }
-  virtual void InputExhausted() MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->mActiveCallback->InputExhausted();
-    }
-  }
-  virtual void DrainComplete() MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->DrainComplete();
-    }
-  }
-  virtual void NotifyResourcesStatusChanged() MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->mActiveCallback->NotifyResourcesStatusChanged();
-    }
-  }
-  virtual void ReleaseMediaResources() MOZ_OVERRIDE
-  {
-    if (mManager->mActiveCallback) {
-      mManager->mActiveCallback->ReleaseMediaResources();
-    }
-  }
-
-  nsRefPtr<SharedDecoderManager> mManager;
-};
-
-SharedDecoderManager::SharedDecoderManager()
-  : mActiveProxy(nullptr)
-  , mActiveCallback(nullptr)
-  , mWaitForInternalDrain(false)
-  , mMonitor("SharedDecoderProxy")
-{
-  mCallback = new SharedDecoderCallback(this);
-}
-
-SharedDecoderManager::~SharedDecoderManager() {}
-
-already_AddRefed<MediaDataDecoder>
-SharedDecoderManager::CreateH264Decoder(
-  const mp4_demuxer::VideoDecoderConfig& aConfig,
-  layers::LayersBackend aLayersBackend, layers::ImageContainer* aImageContainer,
-  MediaTaskQueue* aVideoTaskQueue, MediaDataDecoderCallback* aCallback)
-{
-  if (!mDecoder) {
-    nsAutoPtr<PlatformDecoderModule> platform(PlatformDecoderModule::Create());
-    mDecoder = platform->CreateH264Decoder(
-      aConfig, aLayersBackend, aImageContainer, aVideoTaskQueue, mCallback);
-    if (!mDecoder) {
-      return nullptr;
-    }
-    nsresult rv = mDecoder->Init();
-    NS_ENSURE_SUCCESS(rv, nullptr);
-  }
-
-  nsRefPtr<SharedDecoderProxy> proxy(new SharedDecoderProxy(this, aCallback));
-  return proxy.forget();
-}
-
-void
-SharedDecoderManager::Select(SharedDecoderProxy* aProxy)
-{
-  if (mActiveProxy == aProxy) {
-    return;
-  }
-  SetIdle(mActiveProxy);
-
-  mActiveProxy = aProxy;
-  mActiveCallback = aProxy->mCallback;
-}
-
-void
-SharedDecoderManager::SetIdle(MediaDataDecoder* aProxy)
-{
-  if (aProxy && mActiveProxy == aProxy) {
-    mWaitForInternalDrain = true;
-    mActiveProxy->Drain();
-    MonitorAutoLock mon(mMonitor);
-    while (mWaitForInternalDrain) {
-      mon.Wait();
-    }
-    mActiveProxy->Flush();
-    mActiveProxy = nullptr;
-  }
-}
-
-void
-SharedDecoderManager::DrainComplete()
-{
-  if (mWaitForInternalDrain) {
-    MonitorAutoLock mon(mMonitor);
-    mWaitForInternalDrain = false;
-    mon.NotifyAll();
-  } else {
-    mActiveCallback->DrainComplete();
-  }
-}
-
-SharedDecoderProxy::SharedDecoderProxy(
-  SharedDecoderManager* aManager, MediaDataDecoderCallback* aCallback)
-  : mManager(aManager), mCallback(aCallback)
-{
-}
-
-SharedDecoderProxy::~SharedDecoderProxy() { Shutdown(); }
-
-nsresult
-SharedDecoderProxy::Init()
-{
-  return NS_OK;
-}
-
-nsresult
-SharedDecoderProxy::Input(mp4_demuxer::MP4Sample* aSample)
-{
-  if (mManager->mActiveProxy != this) {
-    mManager->Select(this);
-  }
-  return mManager->mDecoder->Input(aSample);
-  return NS_OK;
-}
-
-nsresult
-SharedDecoderProxy::Flush()
-{
-  if (mManager->mActiveProxy == this) {
-    return mManager->mDecoder->Flush();
-  }
-  return NS_OK;
-}
-
-nsresult
-SharedDecoderProxy::Drain()
-{
-  if (mManager->mActiveProxy == this) {
-    return mManager->mDecoder->Drain();
-  }
-  return NS_OK;
-}
-
-nsresult
-SharedDecoderProxy::Shutdown()
-{
-  mManager->SetIdle(this);
-  return NS_OK;
-}
-
-bool
-SharedDecoderProxy::IsWaitingMediaResources()
-{
-  if (mManager->mActiveProxy == this) {
-    return mManager->mDecoder->IsWaitingMediaResources();
-  }
-  return mManager->mActiveProxy != nullptr;
-}
-
-bool
-SharedDecoderProxy::IsDormantNeeded()
-{
-  return mManager->mDecoder->IsDormantNeeded();
-}
-
-void
-SharedDecoderProxy::ReleaseMediaResources()
-{
-  if (mManager->mActiveProxy == this) {
-    mManager->mDecoder->ReleaseMediaResources();
-  }
-}
-
-void
-SharedDecoderProxy::ReleaseDecoder()
-{
-  if (mManager->mActiveProxy == this) {
-    mManager->mDecoder->ReleaseMediaResources();
-  }
-}
-}
deleted file mode 100644
--- a/dom/media/fmp4/SharedDecoderManager.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/* -*- 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 SHARED_DECODER_MANAGER_H_
-#define SHARED_DECODER_MANAGER_H_
-
-#include "PlatformDecoderModule.h"
-#include "mozilla/Monitor.h"
-
-namespace mozilla
-{
-
-class MediaDataDecoder;
-class SharedDecoderProxy;
-class SharedDecoderCallback;
-
-class SharedDecoderManager
-{
-public:
-  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedDecoderManager)
-
-  SharedDecoderManager();
-
-  already_AddRefed<MediaDataDecoder> CreateH264Decoder(
-    const mp4_demuxer::VideoDecoderConfig& aConfig,
-    layers::LayersBackend aLayersBackend,
-    layers::ImageContainer* aImageContainer, MediaTaskQueue* aVideoTaskQueue,
-    MediaDataDecoderCallback* aCallback);
-
-  void SetReader(MediaDecoderReader* aReader);
-  void Select(SharedDecoderProxy* aProxy);
-  void SetIdle(MediaDataDecoder* aProxy);
-
-  friend class SharedDecoderProxy;
-  friend class SharedDecoderCallback;
-
-private:
-  virtual ~SharedDecoderManager();
-  void DrainComplete();
-
-  nsRefPtr<MediaDataDecoder> mDecoder;
-  SharedDecoderProxy* mActiveProxy;
-  MediaDataDecoderCallback* mActiveCallback;
-  nsAutoPtr<MediaDataDecoderCallback> mCallback;
-  bool mWaitForInternalDrain;
-  Monitor mMonitor;
-};
-
-class SharedDecoderProxy : public MediaDataDecoder
-{
-public:
-  SharedDecoderProxy(SharedDecoderManager* aManager,
-                     MediaDataDecoderCallback* aCallback);
-  virtual ~SharedDecoderProxy();
-
-  virtual nsresult Init() MOZ_OVERRIDE;
-  virtual nsresult Input(mp4_demuxer::MP4Sample* aSample) MOZ_OVERRIDE;
-  virtual nsresult Flush() MOZ_OVERRIDE;
-  virtual nsresult Drain() MOZ_OVERRIDE;
-  virtual nsresult Shutdown() MOZ_OVERRIDE;
-  virtual bool IsWaitingMediaResources() MOZ_OVERRIDE;
-  virtual bool IsDormantNeeded() MOZ_OVERRIDE;
-  virtual void ReleaseMediaResources() MOZ_OVERRIDE;
-  virtual void ReleaseDecoder() MOZ_OVERRIDE;
-
-  friend class SharedDecoderManager;
-
-private:
-  nsRefPtr<SharedDecoderManager> mManager;
-  MediaDataDecoderCallback* mCallback;
-};
-}
-
-#endif
--- a/dom/media/fmp4/moz.build
+++ b/dom/media/fmp4/moz.build
@@ -3,24 +3,22 @@
 # 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/.
 
 EXPORTS += [
     'MP4Decoder.h',
     'MP4Reader.h',
     'PlatformDecoderModule.h',
-    'SharedDecoderManager.h',
 ]
 
 UNIFIED_SOURCES += [
     'BlankDecoderModule.cpp',
     'MP4Decoder.cpp',
     'PlatformDecoderModule.cpp',
-    'SharedDecoderManager.cpp',
 ]
 
 SOURCES += [
     'MP4Reader.cpp',
 ]
 
 if CONFIG['MOZ_WMF']:
     DIRS += [ 'wmf' ];
--- a/dom/media/mediasource/MediaSourceReader.cpp
+++ b/dom/media/mediasource/MediaSourceReader.cpp
@@ -9,17 +9,16 @@
 #include "mozilla/dom/TimeRanges.h"
 #include "DecoderTraits.h"
 #include "MediaDataDecodedListener.h"
 #include "MediaDecoderOwner.h"
 #include "MediaSourceDecoder.h"
 #include "MediaSourceUtils.h"
 #include "SourceBufferDecoder.h"
 #include "TrackBuffer.h"
-#include "SharedDecoderManager.h"
 
 #ifdef MOZ_FMP4
 #include "MP4Decoder.h"
 #include "MP4Reader.h"
 #endif
 
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* GetMediaSourceLog();
@@ -58,17 +57,16 @@ MediaSourceReader::MediaSourceReader(Med
   , mSeekResult(NS_OK)
   , mTimeThreshold(-1)
   , mDropAudioBeforeThreshold(false)
   , mDropVideoBeforeThreshold(false)
   , mEnded(false)
   , mAudioIsSeeking(false)
   , mVideoIsSeeking(false)
   , mHasEssentialTrackBuffers(false)
-  , mSharedDecoderManager(new SharedDecoderManager())
 {
 }
 
 void
 MediaSourceReader::PrepareInitialization()
 {
   ReentrantMonitorAutoEnter mon(mDecoder->GetReentrantMonitor());
   MSE_DEBUG("MediaSourceReader(%p)::PrepareInitialization trackBuffers=%u",
@@ -368,17 +366,16 @@ MediaSourceReader::CreateSubDecoder(cons
 
   // Set a callback on the subreader that forwards calls to this reader.
   // This reader will then forward them onto the state machine via this
   // reader's callback.
   RefPtr<MediaDataDecodedListener<MediaSourceReader>> callback =
     new MediaDataDecodedListener<MediaSourceReader>(this, GetTaskQueue());
   reader->SetCallback(callback);
   reader->SetTaskQueue(GetTaskQueue());
-  reader->SetSharedDecoderManager(mSharedDecoderManager);
   reader->Init(nullptr);
 
   MSE_DEBUG("MediaSourceReader(%p)::CreateSubDecoder subdecoder %p subreader %p",
             this, decoder.get(), reader.get());
   decoder->SetReader(reader);
 #ifdef MOZ_EME
   decoder->SetCDMProxy(mCDMProxy);
 #endif
--- a/dom/media/mediasource/MediaSourceReader.h
+++ b/dom/media/mediasource/MediaSourceReader.h
@@ -170,14 +170,13 @@ private:
   // the mDiscontinuity field set to true once we have the
   // first decoded sample. These flags are set during seeking
   // so we can detect when we have the first decoded sample
   // after a seek.
   bool mAudioIsSeeking;
   bool mVideoIsSeeking;
 
   bool mHasEssentialTrackBuffers;
-  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla
 
 #endif /* MOZILLA_MEDIASOURCEREADER_H_ */