--- a/dom/media/mediasink/AudioSinkWrapper.cpp
+++ b/dom/media/mediasink/AudioSinkWrapper.cpp
@@ -58,52 +58,52 @@ AudioSinkWrapper::GetEndTime(TrackType a
   AssertOwnerThread();
   MOZ_ASSERT(mIsStarted, "Must be called after playback starts.");
   if (aType == TrackInfo::kAudioTrack && mAudioSink) {
     return mAudioSink->GetEndTime().ToMicroseconds();
   }
   return 0;
 }
 
-int64_t
+TimeUnit
 AudioSinkWrapper::GetVideoPosition(TimeStamp aNow) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(!mPlayStartTime.IsNull());
   // Time elapsed since we started playing.
-  int64_t delta = (aNow - mPlayStartTime).ToMicroseconds();
+  double delta = (aNow - mPlayStartTime).ToSeconds();
   // Take playback rate into account.
-  return mPlayDuration + delta * mParams.mPlaybackRate;
+  return mPlayDuration + TimeUnit::FromSeconds(delta * mParams.mPlaybackRate);
 }
 
 int64_t
 AudioSinkWrapper::GetPosition(TimeStamp* aTimeStamp) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(mIsStarted, "Must be called after playback starts.");
 
-  int64_t pos = -1;
+  TimeUnit pos;
   TimeStamp t = TimeStamp::Now();
 
   if (!mAudioEnded) {
     // Rely on the audio sink to report playback position when it is not ended.
-    pos = mAudioSink->GetPosition().ToMicroseconds();
+    pos = mAudioSink->GetPosition();
   } else if (!mPlayStartTime.IsNull()) {
     // Calculate playback position using system clock if we are still playing.
     pos = GetVideoPosition(t);
   } else {
     // Return how long we've played if we are not playing.
     pos = mPlayDuration;
   }
 
   if (aTimeStamp) {
     *aTimeStamp = t;
   }
 
-  return pos;
+  return pos.ToMicroseconds();
 }
 
 bool
 AudioSinkWrapper::HasUnplayedFrames(TrackType aType) const
 {
   AssertOwnerThread();
   return mAudioSink ? mAudioSink->HasUnplayedFrames() : false;
 }
@@ -164,31 +164,31 @@ AudioSinkWrapper::SetPlaying(bool aPlayi
     mAudioSink->SetPlaying(aPlaying);
   }
 
   if (aPlaying) {
     MOZ_ASSERT(mPlayStartTime.IsNull());
     mPlayStartTime = TimeStamp::Now();
   } else {
     // Remember how long we've played.
-    mPlayDuration = GetPosition();
+    mPlayDuration = TimeUnit::FromMicroseconds(GetPosition());
     // mPlayStartTime must be updated later since GetPosition()
     // depends on the value of mPlayStartTime.
     mPlayStartTime = TimeStamp();
   }
 }
 
 void
 AudioSinkWrapper::Start(int64_t aStartTime, const MediaInfo& aInfo)
 {
   AssertOwnerThread();
   MOZ_ASSERT(!mIsStarted, "playback already started.");
 
   mIsStarted = true;
-  mPlayDuration = aStartTime;
+  mPlayDuration = TimeUnit::FromMicroseconds(aStartTime);
   mPlayStartTime = TimeStamp::Now();
 
   // no audio is equivalent to audio ended before video starts.
   mAudioEnded = !aInfo.HasAudio();
 
   if (aInfo.HasAudio()) {
     mAudioSink.reset(mCreator->Create());
     mEndPromise = mAudioSink->Init(mParams);
@@ -232,17 +232,17 @@ AudioSinkWrapper::IsPlaying() const
   return IsStarted() && !mPlayStartTime.IsNull();
 }
 
 void
 AudioSinkWrapper::OnAudioEnded()
 {
   AssertOwnerThread();
   mAudioSinkPromise.Complete();
-  mPlayDuration = GetPosition();
+  mPlayDuration = TimeUnit::FromMicroseconds(GetPosition());
   if (!mPlayStartTime.IsNull()) {
     mPlayStartTime = TimeStamp::Now();
   }
   mAudioEnded = true;
 }
 
 } // namespace media
 } // namespace mozilla

--- a/dom/media/mediasink/AudioSinkWrapper.h
+++ b/dom/media/mediasink/AudioSinkWrapper.h
@@ -46,18 +46,18 @@ class AudioSinkWrapper : public MediaSin
   };
 
 public:
   template <typename Function>
   AudioSinkWrapper(AbstractThread* aOwnerThread, const Function& aFunc)
     : mOwnerThread(aOwnerThread)
     , mCreator(new CreatorImpl<Function>(aFunc))
     , mIsStarted(false)
-    // Give an insane value to facilitate debug if used before playback starts.
-    , mPlayDuration(INT64_MAX)
+    // Give an invalid value to facilitate debug if used before playback starts.
+    , mPlayDuration(TimeUnit::Invalid())
     , mAudioEnded(true)
   {}
 
   const PlaybackParams& GetPlaybackParams() const override;
   void SetPlaybackParams(const PlaybackParams& aParams) override;
 
   RefPtr<GenericPromise> OnEnded(TrackType aType) override;
   int64_t GetEndTime(TrackType aType) const override;
@@ -78,30 +78,30 @@ public:
 
 private:
   virtual ~AudioSinkWrapper();
 
   void AssertOwnerThread() const {
     MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
   }
 
-  int64_t GetVideoPosition(TimeStamp aNow) const;
+  TimeUnit GetVideoPosition(TimeStamp aNow) const;
 
   void OnAudioEnded();
 
   const RefPtr<AbstractThread> mOwnerThread;
   UniquePtr<Creator> mCreator;
   UniquePtr<AudioSink> mAudioSink;
   RefPtr<GenericPromise> mEndPromise;
 
   bool mIsStarted;
   PlaybackParams mParams;
 
   TimeStamp mPlayStartTime;
-  int64_t mPlayDuration;
+  TimeUnit mPlayDuration;
 
   bool mAudioEnded;
   MozPromiseRequestHolder<GenericPromise> mAudioSinkPromise;
 };
 
 } // namespace media
 } // namespace mozilla