--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -3244,17 +3244,17 @@ MediaDecoderStateMachine::WaitForData(Me
 }
 
 void
 MediaDecoderStateMachine::StartMediaSink()
 {
   MOZ_ASSERT(OnTaskQueue());
   if (!mMediaSink->IsStarted()) {
     mAudioCompleted = false;
-    mMediaSink->Start(GetMediaTime(), Info());
+    mMediaSink->Start(TimeUnit::FromMicroseconds(GetMediaTime()), Info());
 
     auto videoPromise = mMediaSink->OnEnded(TrackInfo::kVideoTrack);
     auto audioPromise = mMediaSink->OnEnded(TrackInfo::kAudioTrack);
 
     if (audioPromise) {
       audioPromise->Then(
         OwnerThread(), __func__, this,
         &MediaDecoderStateMachine::OnMediaSinkAudioComplete,
@@ -3471,17 +3471,17 @@ MediaDecoderStateMachine::ResetDecode(Tr
 
   mReader->ResetDecode(aTracks);
 }
 
 int64_t
 MediaDecoderStateMachine::GetClock(TimeStamp* aTimeStamp) const
 {
   MOZ_ASSERT(OnTaskQueue());
-  int64_t clockTime = mMediaSink->GetPosition(aTimeStamp);
+  int64_t clockTime = mMediaSink->GetPosition(aTimeStamp).ToMicroseconds();
   NS_ASSERTION(GetMediaTime() <= clockTime, "Clock should go forwards.");
   return clockTime;
 }
 
 void
 MediaDecoderStateMachine::UpdatePlaybackPositionPeriodically()
 {
   MOZ_ASSERT(OnTaskQueue());
@@ -3645,27 +3645,27 @@ MediaDecoderStateMachine::IsShutdown() c
   return mIsShutdown;
 }
 
 int64_t
 MediaDecoderStateMachine::AudioEndTime() const
 {
   MOZ_ASSERT(OnTaskQueue());
   if (mMediaSink->IsStarted()) {
-    return mMediaSink->GetEndTime(TrackInfo::kAudioTrack);
+    return mMediaSink->GetEndTime(TrackInfo::kAudioTrack).ToMicroseconds();
   }
   return 0;
 }
 
 int64_t
 MediaDecoderStateMachine::VideoEndTime() const
 {
   MOZ_ASSERT(OnTaskQueue());
   if (mMediaSink->IsStarted()) {
-    return mMediaSink->GetEndTime(TrackInfo::kVideoTrack);
+    return mMediaSink->GetEndTime(TrackInfo::kVideoTrack).ToMicroseconds();
   }
   return 0;
 }
 
 void
 MediaDecoderStateMachine::OnMediaSinkVideoComplete()
 {
   MOZ_ASSERT(OnTaskQueue());

--- a/dom/media/mediasink/AudioSinkWrapper.cpp
+++ b/dom/media/mediasink/AudioSinkWrapper.cpp
@@ -47,39 +47,39 @@ AudioSinkWrapper::OnEnded(TrackType aTyp
   AssertOwnerThread();
   MOZ_ASSERT(mIsStarted, "Must be called after playback starts.");
   if (aType == TrackInfo::kAudioTrack) {
     return mEndPromise;
   }
   return nullptr;
 }
 
-int64_t
+TimeUnit
 AudioSinkWrapper::GetEndTime(TrackType aType) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(mIsStarted, "Must be called after playback starts.");
   if (aType == TrackInfo::kAudioTrack && mAudioSink) {
-    return mAudioSink->GetEndTime().ToMicroseconds();
+    return mAudioSink->GetEndTime();
   }
-  return 0;
+  return TimeUnit::Zero();
 }
 
 TimeUnit
 AudioSinkWrapper::GetVideoPosition(TimeStamp aNow) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(!mPlayStartTime.IsNull());
   // Time elapsed since we started playing.
   double delta = (aNow - mPlayStartTime).ToSeconds();
   // Take playback rate into account.
   return mPlayDuration + TimeUnit::FromSeconds(delta * mParams.mPlaybackRate);
 }
 
-int64_t
+TimeUnit
 AudioSinkWrapper::GetPosition(TimeStamp* aTimeStamp) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(mIsStarted, "Must be called after playback starts.");
 
   TimeUnit pos;
   TimeStamp t = TimeStamp::Now();
 
@@ -93,17 +93,17 @@ AudioSinkWrapper::GetPosition(TimeStamp*
     // Return how long we've played if we are not playing.
     pos = mPlayDuration;
   }
 
   if (aTimeStamp) {
     *aTimeStamp = t;
   }
 
-  return pos.ToMicroseconds();
+  return pos;
 }
 
 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 = TimeUnit::FromMicroseconds(GetPosition());
+    mPlayDuration = 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)
+AudioSinkWrapper::Start(const TimeUnit& aStartTime, const MediaInfo& aInfo)
 {
   AssertOwnerThread();
   MOZ_ASSERT(!mIsStarted, "playback already started.");
 
   mIsStarted = true;
-  mPlayDuration = TimeUnit::FromMicroseconds(aStartTime);
+  mPlayDuration = 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 = TimeUnit::FromMicroseconds(GetPosition());
+  mPlayDuration = 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
@@ -55,26 +55,26 @@ public:
     , 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;
-  int64_t GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
+  TimeUnit GetEndTime(TrackType aType) const override;
+  TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
   bool HasUnplayedFrames(TrackType aType) const override;
 
   void SetVolume(double aVolume) override;
   void SetPlaybackRate(double aPlaybackRate) override;
   void SetPreservesPitch(bool aPreservesPitch) override;
   void SetPlaying(bool aPlaying) override;
 
-  void Start(int64_t aStartTime, const MediaInfo& aInfo) override;
+  void Start(const TimeUnit& aStartTime, const MediaInfo& aInfo) override;
   void Stop() override;
   bool IsStarted() const override;
   bool IsPlaying() const override;
 
   void Shutdown() override;
 
 private:
   virtual ~AudioSinkWrapper();

--- a/dom/media/mediasink/DecodedStream.cpp
+++ b/dom/media/mediasink/DecodedStream.cpp
@@ -289,22 +289,22 @@ DecodedStream::OnEnded(TrackType aType)
     return mFinishPromise;
   } else if (aType == TrackInfo::kVideoTrack && mInfo.HasVideo()) {
     return mFinishPromise;
   }
   return nullptr;
 }
 
 void
-DecodedStream::Start(int64_t aStartTime, const MediaInfo& aInfo)
+DecodedStream::Start(const media::TimeUnit& aStartTime, const MediaInfo& aInfo)
 {
   AssertOwnerThread();
   MOZ_ASSERT(mStartTime.isNothing(), "playback already started.");
 
-  mStartTime.emplace(FromMicroseconds(aStartTime));
+  mStartTime.emplace(aStartTime);
   mLastOutputTime = media::TimeUnit::Zero();
   mInfo = aInfo;
   mPlaying = true;
   ConnectListener();
 
   class R : public Runnable {
     typedef MozPromiseHolder<GenericPromise> Promise;
   public:
@@ -341,17 +341,17 @@ DecodedStream::Start(int64_t aStartTime,
     RefPtr<OutputStreamManager> mOutputStreamManager;
     UniquePtr<DecodedStreamData> mData;
     const RefPtr<AbstractThread> mAbstractMainThread;
   };
 
   MozPromiseHolder<GenericPromise> promise;
   mFinishPromise = promise.Ensure(__func__);
   PlaybackInfoInit init {
-    FromMicroseconds(aStartTime), aInfo
+    aStartTime, aInfo
   };
   nsCOMPtr<nsIRunnable> r =
     new R(Move(init), Move(promise), mOutputStreamManager, mAbstractMainThread);
   SyncRunnable::DispatchToThread(
     SystemGroup::EventTargetFor(mozilla::TaskCategory::Other), r);
   mData = static_cast<R*>(r.get())->ReleaseData();
 
   if (mData) {
@@ -708,51 +708,51 @@ DecodedStream::SendData()
                   (!mInfo.HasVideo() || mVideoQueue.IsFinished());
 
   if (finished && !mData->mHaveSentFinish) {
     mData->mHaveSentFinish = true;
     mData->mStream->Finish();
   }
 }
 
-int64_t
+media::TimeUnit
 DecodedStream::GetEndTime(TrackType aType) const
 {
   AssertOwnerThread();
   if (aType == TrackInfo::kAudioTrack && mInfo.HasAudio() && mData) {
     auto t = mStartTime.ref() + FramesToTimeUnit(
       mData->mAudioFramesWritten, mInfo.mAudio.mRate);
     if (t.IsValid()) {
-      return t.ToMicroseconds();
+      return t;
     }
   } else if (aType == TrackInfo::kVideoTrack && mData) {
-    return mData->mNextVideoTime.ToMicroseconds();
+    return mData->mNextVideoTime;
   }
-  return 0;
+  return media::TimeUnit::Zero();
 }
 
-int64_t
+media::TimeUnit
 DecodedStream::GetPosition(TimeStamp* aTimeStamp) const
 {
   AssertOwnerThread();
   // This is only called after MDSM starts playback. So mStartTime is
   // guaranteed to be something.
   MOZ_ASSERT(mStartTime.isSome());
   if (aTimeStamp) {
     *aTimeStamp = TimeStamp::Now();
   }
-  return (mStartTime.ref() + mLastOutputTime).ToMicroseconds();
+  return mStartTime.ref() + mLastOutputTime;
 }
 
 void
 DecodedStream::NotifyOutput(int64_t aTime)
 {
   AssertOwnerThread();
   mLastOutputTime = FromMicroseconds(aTime);
-  int64_t currentTime = GetPosition();
+  int64_t currentTime = GetPosition().ToMicroseconds();
 
   // Remove audio samples that have been played by MSG from the queue.
   RefPtr<AudioData> a = mAudioQueue.PeekFront();
   for (; a && a->mTime < currentTime;) {
     RefPtr<AudioData> releaseMe = mAudioQueue.PopFront();
     a = mAudioQueue.PeekFront();
   }
 }

--- a/dom/media/mediasink/DecodedStream.h
+++ b/dom/media/mediasink/DecodedStream.h
@@ -42,30 +42,30 @@ public:
                 const bool& aSameOrigin,
                 const PrincipalHandle& aPrincipalHandle);
 
   // MediaSink functions.
   const PlaybackParams& GetPlaybackParams() const override;
   void SetPlaybackParams(const PlaybackParams& aParams) override;
 
   RefPtr<GenericPromise> OnEnded(TrackType aType) override;
-  int64_t GetEndTime(TrackType aType) const override;
-  int64_t GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
+  media::TimeUnit GetEndTime(TrackType aType) const override;
+  media::TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
   bool HasUnplayedFrames(TrackType aType) const override
   {
     // TODO: implement this.
     return false;
   }
 
   void SetVolume(double aVolume) override;
   void SetPlaybackRate(double aPlaybackRate) override;
   void SetPreservesPitch(bool aPreservesPitch) override;
   void SetPlaying(bool aPlaying) override;
 
-  void Start(int64_t aStartTime, const MediaInfo& aInfo) override;
+  void Start(const media::TimeUnit& aStartTime, const MediaInfo& aInfo) override;
   void Stop() override;
   bool IsStarted() const override;
   bool IsPlaying() const override;
 
   nsCString GetDebugInfo() override;
 
 protected:
   virtual ~DecodedStream();

--- a/dom/media/mediasink/MediaSink.h
+++ b/dom/media/mediasink/MediaSink.h
@@ -57,25 +57,25 @@ public:
   // Return a promise which is resolved when the track finishes
   // or null if no such track.
   // Must be called after playback starts.
   virtual RefPtr<GenericPromise> OnEnded(TrackType aType) = 0;
 
   // Return the end time of the audio/video data that has been consumed
   // or 0 if no such track.
   // Must be called after playback starts.
-  virtual int64_t GetEndTime(TrackType aType) const = 0;
+  virtual TimeUnit GetEndTime(TrackType aType) const = 0;
 
   // Return playback position of the media.
   // Since A/V sync is always maintained by this sink, there is no need to
   // specify whether we want to get audio or video position.
   // aTimeStamp returns the timeStamp corresponding to the returned position
   // which is used by the compositor to derive the render time of video frames.
   // Must be called after playback starts.
-  virtual int64_t GetPosition(TimeStamp* aTimeStamp = nullptr) const = 0;
+  virtual TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) const = 0;
 
   // Return true if there are data consumed but not played yet.
   // Can be called in any state.
   virtual bool HasUnplayedFrames(TrackType aType) const = 0;
 
   // Set volume of the audio track.
   // Do nothing if this sink has no audio track.
   // Can be called in any state.
@@ -95,17 +95,17 @@ public:
 
   // Single frame rendering operation may need to be done before playback
   // started (1st frame) or right after seek completed or playback stopped.
   // Do nothing if this sink has no video track. Can be called in any state.
   virtual void Redraw(const VideoInfo& aInfo) {};
 
   // Begin a playback session with the provided start time and media info.
   // Must be called when playback is stopped.
-  virtual void Start(int64_t aStartTime, const MediaInfo& aInfo) = 0;
+  virtual void Start(const TimeUnit& aStartTime, const MediaInfo& aInfo) = 0;
 
   // Finish a playback session.
   // Must be called after playback starts.
   virtual void Stop() = 0;
 
   // Return true if playback has started.
   // Can be called in any state.
   virtual bool IsStarted() const = 0;

--- a/dom/media/mediasink/VideoSink.cpp
+++ b/dom/media/mediasink/VideoSink.cpp
@@ -78,31 +78,31 @@ VideoSink::OnEnded(TrackType aType)
   if (aType == TrackInfo::kAudioTrack) {
     return mAudioSink->OnEnded(aType);
   } else if (aType == TrackInfo::kVideoTrack) {
     return mEndPromise;
   }
   return nullptr;
 }
 
-int64_t
+TimeUnit
 VideoSink::GetEndTime(TrackType aType) const
 {
   AssertOwnerThread();
   MOZ_ASSERT(mAudioSink->IsStarted(), "Must be called after playback starts.");
 
   if (aType == TrackInfo::kVideoTrack) {
-    return mVideoFrameEndTime.ToMicroseconds();
+    return mVideoFrameEndTime;
   } else if (aType == TrackInfo::kAudioTrack) {
     return mAudioSink->GetEndTime(aType);
   }
-  return 0;
+  return TimeUnit::Zero();
 }
 
-int64_t
+TimeUnit
 VideoSink::GetPosition(TimeStamp* aTimeStamp) const
 {
   AssertOwnerThread();
   return mAudioSink->GetPosition(aTimeStamp);
 }
 
 bool
 VideoSink::HasUnplayedFrames(TrackType aType) const
@@ -159,17 +159,17 @@ VideoSink::SetPlaying(bool aPlaying)
     // There's no thread in VideoSink for pulling video frames, need to trigger
     // rendering while becoming playing status. because the VideoQueue may be
     // full already.
     TryUpdateRenderedVideoFrames();
   }
 }
 
 void
-VideoSink::Start(int64_t aStartTime, const MediaInfo& aInfo)
+VideoSink::Start(const TimeUnit& aStartTime, const MediaInfo& aInfo)
 {
   AssertOwnerThread();
   VSINK_LOG("[%s]", __func__);
 
   mAudioSink->Start(aStartTime, aInfo);
 
   mHasVideo = aInfo.HasVideo();
 
@@ -405,17 +405,17 @@ VideoSink::RenderVideoFrames(int32_t aMa
 void
 VideoSink::UpdateRenderedVideoFrames()
 {
   AssertOwnerThread();
   MOZ_ASSERT(mAudioSink->IsPlaying(), "should be called while playing.");
 
   // Get the current playback position.
   TimeStamp nowTime;
-  const int64_t clockTime = mAudioSink->GetPosition(&nowTime);
+  const int64_t clockTime = mAudioSink->GetPosition(&nowTime).ToMicroseconds();
   NS_ASSERTION(clockTime >= 0, "Should have positive clock time.");
 
   // Skip frames up to the playback position.
   int64_t lastFrameEndTime = 0;
   while (VideoQueue().GetSize() > mMinVideoQueueSize &&
          clockTime >= VideoQueue().PeekFront()->GetEndTime()) {
     RefPtr<VideoData> frame = VideoQueue().PopFront();
     lastFrameEndTime = frame->GetEndTime();

--- a/dom/media/mediasink/VideoSink.h
+++ b/dom/media/mediasink/VideoSink.h
@@ -37,33 +37,33 @@ public:
             uint32_t aVQueueSentToCompositerSize);
 
   const PlaybackParams& GetPlaybackParams() const override;
 
   void SetPlaybackParams(const PlaybackParams& aParams) override;
 
   RefPtr<GenericPromise> OnEnded(TrackType aType) override;
 
-  int64_t GetEndTime(TrackType aType) const override;
+  TimeUnit GetEndTime(TrackType aType) const override;
 
-  int64_t GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
+  TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) const override;
 
   bool HasUnplayedFrames(TrackType aType) const override;
 
   void SetPlaybackRate(double aPlaybackRate) override;
 
   void SetVolume(double aVolume) override;
 
   void SetPreservesPitch(bool aPreservesPitch) override;
 
   void SetPlaying(bool aPlaying) override;
 
   void Redraw(const VideoInfo& aInfo) override;
 
-  void Start(int64_t aStartTime, const MediaInfo& aInfo) override;
+  void Start(const TimeUnit& aStartTime, const MediaInfo& aInfo) override;
 
   void Stop() override;
 
   bool IsStarted() const override;
 
   bool IsPlaying() const override;
 
   void Shutdown() override;