Backed out changeset 46b6cb002a34 (bug 1036849) for leaks on a CLOSED TREE

dom/media/MediaDecoderReader.h

@@ -20,7 +20,6 @@ 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
@@ -48,7 +47,6 @@ public:
   // 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.

dom/media/fmp4/MP4Reader.cpp

@@ -14,7 +14,6 @@
 #include "SharedThreadPool.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/TimeRanges.h"
-#include "SharedDecoderManager.h"
 
 #ifdef MOZ_EME
 #include "mozilla/CDMProxy.h"
@@ -415,21 +414,12 @@ MP4Reader::ReadMetadata(MediaInfo* aInfo,
     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);
@@ -483,6 +473,12 @@ MP4Reader::GetDecoderData(TrackType aTrack)
   return (aTrack == kAudio) ? mAudio : mVideo;
 }
 
+MediaDataDecoder*
+MP4Reader::Decoder(TrackType aTrack)
+{
+  return GetDecoderData(aTrack).mDecoder;
+}
+
 MP4Sample*
 MP4Reader::PopSample(TrackType aTrack)
 {
@@ -888,21 +884,4 @@ void MP4Reader::NotifyResourcesStatusChanged()
 #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

dom/media/fmp4/MP4Reader.h

@@ -62,12 +62,9 @@ public:
   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;
 
@@ -182,6 +179,7 @@ private:
   uint64_t mLastReportedNumDecodedFrames;
 
   DecoderData& GetDecoderData(mp4_demuxer::TrackType aTrack);
+  MediaDataDecoder* Decoder(mp4_demuxer::TrackType aTrack);
 
   layers::LayersBackend mLayersBackendType;
 
@@ -195,7 +193,6 @@ private:
 
   bool mIndexReady;
   Monitor mIndexMonitor;
-  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla

dom/media/fmp4/PlatformDecoderModule.h

@@ -230,8 +230,8 @@ public:
   virtual bool IsDormantNeeded() {
     return false;
   };
-  virtual void ReleaseMediaResources() {}
-  virtual void ReleaseDecoder() {}
+  virtual void ReleaseMediaResources() {};
+  virtual void ReleaseDecoder() {};
 };
 
 } // namespace mozilla

dom/media/fmp4/SharedDecoderManager.cpp

@@ -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();
-  }
-}
-}

dom/media/fmp4/SharedDecoderManager.h

@@ -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

dom/media/fmp4/moz.build

@@ -8,14 +8,12 @@ EXPORTS += [
     'MP4Decoder.h',
     'MP4Reader.h',
     'PlatformDecoderModule.h',
-    'SharedDecoderManager.h',
 ]
 
 UNIFIED_SOURCES += [
     'BlankDecoderModule.cpp',
     'MP4Decoder.cpp',
     'PlatformDecoderModule.cpp',
-    'SharedDecoderManager.cpp',
 ]
 
 SOURCES += [

dom/media/mediasource/MediaSourceReader.cpp

@@ -14,7 +14,6 @@
 #include "MediaSourceUtils.h"
 #include "SourceBufferDecoder.h"
 #include "TrackBuffer.h"
-#include "SharedDecoderManager.h"
 
 #ifdef MOZ_FMP4
 #include "MP4Decoder.h"
@@ -63,7 +62,6 @@ MediaSourceReader::MediaSourceReader(MediaSourceDecoder* aDecoder)
   , mAudioIsSeeking(false)
   , mVideoIsSeeking(false)
   , mHasEssentialTrackBuffers(false)
-  , mSharedDecoderManager(new SharedDecoderManager())
 {
 }
 
@@ -373,7 +371,6 @@ MediaSourceReader::CreateSubDecoder(const nsACString& aType)
     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",

dom/media/mediasource/MediaSourceReader.h

@@ -175,7 +175,6 @@ private:
   bool mVideoIsSeeking;
 
   bool mHasEssentialTrackBuffers;
-  nsRefPtr<SharedDecoderManager> mSharedDecoderManager;
 };
 
 } // namespace mozilla