Merge MediaPeriodInfoSequence into MediaPeriodQueue

MediaPeriodInfoSequence has functionality for determining what MediaPeriod
should be loaded next. Move this into the queue as an initial step towards
moving logic concerning updating the queue of media periods out of
ExoPlayerImplInternal.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=183391114

library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java

@@ -16,7 +16,6 @@
 package com.google.android.exoplayer2;
 package com.google.android.exoplayer2;
 
 
 import android.util.Log;
 import android.util.Log;
-import com.google.android.exoplayer2.MediaPeriodInfoSequence.MediaPeriodInfo;
 import com.google.android.exoplayer2.source.ClippingMediaPeriod;
 import com.google.android.exoplayer2.source.ClippingMediaPeriod;
 import com.google.android.exoplayer2.source.EmptySampleStream;
 import com.google.android.exoplayer2.source.EmptySampleStream;
 import com.google.android.exoplayer2.source.MediaPeriod;
 import com.google.android.exoplayer2.source.MediaPeriod;
@@ -52,19 +51,31 @@ import com.google.android.exoplayer2.util.Assertions;
 
 
   private TrackSelectorResult periodTrackSelectorResult;
   private TrackSelectorResult periodTrackSelectorResult;
 
 
+  /**
+   * Creates a new holder with information required to play it as part of a timeline.
+   *
+   * @param rendererCapabilities The renderer capabilities.
+   * @param rendererPositionOffsetUs The time offset of the start of the media period to provide to
+   *     renderers.
+   * @param trackSelector The track selector.
+   * @param allocator The allocator.
+   * @param mediaSource The media source that produced the media period.
+   * @param uid The unique identifier for the containing timeline period.
+   * @param info Information used to identify this media period in its timeline period.
+   */
   public MediaPeriodHolder(
   public MediaPeriodHolder(
       RendererCapabilities[] rendererCapabilities,
       RendererCapabilities[] rendererCapabilities,
       long rendererPositionOffsetUs,
       long rendererPositionOffsetUs,
       TrackSelector trackSelector,
       TrackSelector trackSelector,
       Allocator allocator,
       Allocator allocator,
       MediaSource mediaSource,
       MediaSource mediaSource,
-      Object periodUid,
+      Object uid,
       MediaPeriodInfo info) {
       MediaPeriodInfo info) {
     this.rendererCapabilities = rendererCapabilities;
     this.rendererCapabilities = rendererCapabilities;
     this.rendererPositionOffsetUs = rendererPositionOffsetUs - info.startPositionUs;
     this.rendererPositionOffsetUs = rendererPositionOffsetUs - info.startPositionUs;
     this.trackSelector = trackSelector;
     this.trackSelector = trackSelector;
     this.mediaSource = mediaSource;
     this.mediaSource = mediaSource;
-    this.uid = Assertions.checkNotNull(periodUid);
+    this.uid = Assertions.checkNotNull(uid);
     this.info = info;
     this.info = info;
     sampleStreams = new SampleStream[rendererCapabilities.length];
     sampleStreams = new SampleStream[rendererCapabilities.length];
     mayRetainStreamFlags = new boolean[rendererCapabilities.length];
     mayRetainStreamFlags = new boolean[rendererCapabilities.length];
@@ -121,12 +132,13 @@ import com.google.android.exoplayer2.util.Assertions;
     return !prepared ? 0 : mediaPeriod.getNextLoadPositionUs();
     return !prepared ? 0 : mediaPeriod.getNextLoadPositionUs();
   }
   }
 
 
-  public void handlePrepared(float playbackSpeed) throws ExoPlaybackException {
+  public TrackSelectorResult handlePrepared(float playbackSpeed) throws ExoPlaybackException {
     prepared = true;
     prepared = true;
     selectTracks(playbackSpeed);
     selectTracks(playbackSpeed);
     long newStartPositionUs = applyTrackSelection(info.startPositionUs, false);
     long newStartPositionUs = applyTrackSelection(info.startPositionUs, false);
     rendererPositionOffsetUs += info.startPositionUs - newStartPositionUs;
     rendererPositionOffsetUs += info.startPositionUs - newStartPositionUs;
     info = info.copyWithStartPositionUs(newStartPositionUs);
     info = info.copyWithStartPositionUs(newStartPositionUs);
+    return trackSelectorResult;
   }
   }
 
 
   public void reevaluateBuffer(long rendererPositionUs) {
   public void reevaluateBuffer(long rendererPositionUs) {

library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolderQueue.java

-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.google.android.exoplayer2;
-
-import com.google.android.exoplayer2.util.Assertions;
-
-/**
- * Holds a queue of {@link MediaPeriodHolder}s from the currently playing period holder at the front
- * to the loading period holder at the end of the queue. Also has a reference to the reading period
- * holder.
- */
-/* package */ final class MediaPeriodHolderQueue {
-
-  private MediaPeriodHolder playing;
-  private MediaPeriodHolder reading;
-  private MediaPeriodHolder loading;
-  private int length;
-
-  /**
-   * Returns the loading period holder which is at the end of the queue, or null if the queue is
-   * empty.
-   */
-  public MediaPeriodHolder getLoadingPeriod() {
-    return loading;
-  }
-
-  /**
-   * Returns the playing period holder which is at the front of the queue, or null if the queue is
-   * empty or hasn't started playing.
-   */
-  public MediaPeriodHolder getPlayingPeriod() {
-    return playing;
-  }
-
-  /**
-   * Returns the reading period holder, or null if the queue is empty or the player hasn't started
-   * reading.
-   */
-  public MediaPeriodHolder getReadingPeriod() {
-    return reading;
-  }
-
-  /**
-   * Returns the period holder in the front of the queue which is the playing period holder when
-   * playing, or null if the queue is empty.
-   */
-  public MediaPeriodHolder getFrontPeriod() {
-    return hasPlayingPeriod() ? playing : loading;
-  }
-
-  /** Returns the current length of the queue. */
-  public int getLength() {
-    return length;
-  }
-
-  /** Returns whether the reading and playing period holders are set. */
-  public boolean hasPlayingPeriod() {
-    return playing != null;
-  }
-
-  /**
-   * Continues reading from the next period holder in the queue.
-   *
-   * @return The updated reading period holder.
-   */
-  public MediaPeriodHolder advanceReadingPeriod() {
-    Assertions.checkState(reading != null && reading.next != null);
-    reading = reading.next;
-    return reading;
-  }
-
-  /** Enqueues a new period holder at the end, which becomes the new loading period holder. */
-  public void enqueueLoadingPeriod(MediaPeriodHolder mediaPeriodHolder) {
-    Assertions.checkState(mediaPeriodHolder != null);
-    if (loading != null) {
-      Assertions.checkState(hasPlayingPeriod());
-      loading.next = mediaPeriodHolder;
-    }
-    loading = mediaPeriodHolder;
-    length++;
-  }
-
-  /**
-   * Dequeues the playing period holder from the front of the queue and advances the playing period
-   * holder to be the next item in the queue. If the playing period holder is unset, set it to the
-   * item in the front of the queue.
-   *
-   * @return The updated playing period holder, or null if the queue is or becomes empty.
-   */
-  public MediaPeriodHolder advancePlayingPeriod() {
-    if (playing != null) {
-      if (playing == reading) {
-        reading = playing.next;
-      }
-      playing.release();
-      playing = playing.next;
-      length--;
-      if (length == 0) {
-        loading = null;
-      }
-    } else {
-      playing = loading;
-      reading = loading;
-    }
-    return playing;
-  }
-
-  /**
-   * Removes all period holders after the given period holder. This process may also remove the
-   * currently reading period holder. If that is the case, the reading period holder is set to be
-   * the same as the playing period holder at the front of the queue.
-   *
-   * @param mediaPeriodHolder The media period holder that shall be the new end of the queue.
-   * @return Whether the reading period has been removed.
-   */
-  public boolean removeAfter(MediaPeriodHolder mediaPeriodHolder) {
-    Assertions.checkState(mediaPeriodHolder != null);
-    boolean removedReading = false;
-    loading = mediaPeriodHolder;
-    while (mediaPeriodHolder.next != null) {
-      mediaPeriodHolder = mediaPeriodHolder.next;
-      if (mediaPeriodHolder == reading) {
-        reading = playing;
-        removedReading = true;
-      }
-      mediaPeriodHolder.release();
-      length--;
-    }
-    loading.next = null;
-    return removedReading;
-  }
-
-  /** Clears the queue. */
-  public void clear() {
-    MediaPeriodHolder front = getFrontPeriod();
-    if (front != null) {
-      front.release();
-      removeAfter(front);
-    }
-    playing = null;
-    loading = null;
-    reading = null;
-    length = 0;
-  }
-}

library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodInfo.java

+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2;
+
+import com.google.android.exoplayer2.source.MediaPeriod;
+import com.google.android.exoplayer2.source.MediaSource.MediaPeriodId;
+
+/** Stores the information required to load and play a {@link MediaPeriod}. */
+/* package */ final class MediaPeriodInfo {
+
+  /** The media period's identifier. */
+  public final MediaPeriodId id;
+  /** The start position of the media to play within the media period, in microseconds. */
+  public final long startPositionUs;
+  /**
+   * The end position of the media to play within the media period, in microseconds, or {@link
+   * C#TIME_END_OF_SOURCE} if the end position is the end of the media period.
+   */
+  public final long endPositionUs;
+  /**
+   * If this is an ad, the position to play in the next content media period. {@link C#TIME_UNSET}
+   * otherwise.
+   */
+  public final long contentPositionUs;
+  /**
+   * The duration of the media to play within the media period, in microseconds, or {@link
+   * C#TIME_UNSET} if not known.
+   */
+  public final long durationUs;
+  /**
+   * Whether this is the last media period in its timeline period (e.g., a postroll ad, or a media
+   * period corresponding to a timeline period without ads).
+   */
+  public final boolean isLastInTimelinePeriod;
+  /**
+   * Whether this is the last media period in the entire timeline. If true, {@link
+   * #isLastInTimelinePeriod} will also be true.
+   */
+  public final boolean isFinal;
+
+  MediaPeriodInfo(
+      MediaPeriodId id,
+      long startPositionUs,
+      long endPositionUs,
+      long contentPositionUs,
+      long durationUs,
+      boolean isLastInTimelinePeriod,
+      boolean isFinal) {
+    this.id = id;
+    this.startPositionUs = startPositionUs;
+    this.endPositionUs = endPositionUs;
+    this.contentPositionUs = contentPositionUs;
+    this.durationUs = durationUs;
+    this.isLastInTimelinePeriod = isLastInTimelinePeriod;
+    this.isFinal = isFinal;
+  }
+
+  /**
+   * Returns a copy of this instance with the period identifier's period index set to the specified
+   * value.
+   */
+  public MediaPeriodInfo copyWithPeriodIndex(int periodIndex) {
+    return new MediaPeriodInfo(
+        id.copyWithPeriodIndex(periodIndex),
+        startPositionUs,
+        endPositionUs,
+        contentPositionUs,
+        durationUs,
+        isLastInTimelinePeriod,
+        isFinal);
+  }
+
+  /** Returns a copy of this instance with the start position set to the specified value. */
+  public MediaPeriodInfo copyWithStartPositionUs(long startPositionUs) {
+    return new MediaPeriodInfo(
+        id,
+        startPositionUs,
+        endPositionUs,
+        contentPositionUs,
+        durationUs,
+        isLastInTimelinePeriod,
+        isFinal);
+  }
+}