Invert logic for readbility in the code selector.

novoda · Jun 26, 2017 · 65008cf · 65008cf
1 parent 4748c1d
commit 65008cf
Show file tree

Hide file tree

Showing 7 changed files with 41 additions and 45 deletions.
diff --git a/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerCreator.java b/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerCreator.java
@@ -28,14 +28,14 @@ class ExoPlayerCreator {
     }
 
     @NonNull
-    public SimpleExoPlayer create(DrmSessionCreator drmSessionCreator, ExoPlayerDrmSessionEventListener exoPlayerDrmSessionEventListener, boolean useSecureCodec) {
+    public SimpleExoPlayer create(DrmSessionCreator drmSessionCreator, ExoPlayerDrmSessionEventListener exoPlayerDrmSessionEventListener, boolean downgradeSecureDecoder) {
         DrmSessionManager<FrameworkMediaCrypto> drmSessionManager = drmSessionCreator.create(exoPlayerDrmSessionEventListener);
         RenderersFactory renderersFactory = new SimpleRenderersFactory(
                 context,
                 drmSessionManager,
                 EXTENSION_RENDERER_MODE_OFF,
                 DEFAULT_ALLOWED_VIDEO_JOINING_TIME_MS,
-                CodecSelector.newInstance(useSecureCodec)
+                SecurityDowngradingCodecSelector.newInstance(downgradeSecureDecoder)
         );
 
         DefaultLoadControl loadControl = new DefaultLoadControl();

diff --git a/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerFacade.java b/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerFacade.java
@@ -100,8 +100,8 @@ void stop() {
         exoPlayer.stop();
     }
 
-    void loadVideo(DrmSessionCreator drmSessionCreator, Uri uri, ContentType contentType, ExoPlayerForwarder forwarder, boolean useSecureCodec) {
-        exoPlayer = exoPlayerCreator.create(drmSessionCreator, forwarder.drmSessionEventListener(), useSecureCodec);
+    void loadVideo(DrmSessionCreator drmSessionCreator, Uri uri, ContentType contentType, ExoPlayerForwarder forwarder, boolean downgradeSecureDecoder) {
+        exoPlayer = exoPlayerCreator.create(drmSessionCreator, forwarder.drmSessionEventListener(), downgradeSecureDecoder);
         rendererTypeRequester = rendererTypeRequesterCreator.createfrom(exoPlayer);
         exoPlayer.addListener(forwarder.exoPlayerEventListener());
         exoPlayer.setVideoDebugListener(forwarder.videoRendererEventListener());

diff --git a/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerTwoImpl.java b/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerTwoImpl.java
@@ -30,7 +30,7 @@ public class ExoPlayerTwoImpl implements Player {
     private final ExoPlayerForwarder forwarder;
     private final Heart heart;
     private final DrmSessionCreator drmSessionCreator;
-    private final boolean useSecureCodec;
+    private final boolean downgradeSecureDecoder;
     private final LoadTimeout loadTimeout;
 
     private SurfaceHolderRequester surfaceHolderRequester;
@@ -47,14 +47,14 @@ public class ExoPlayerTwoImpl implements Player {
                      LoadTimeout loadTimeoutParam,
                      Heart heart,
                      DrmSessionCreator drmSessionCreator,
-                     boolean useSecureCodec) {
+                     boolean downgradeSecureDecoder) {
         this.exoPlayer = exoPlayer;
         this.listenersHolder = listenersHolder;
         this.loadTimeout = loadTimeoutParam;
         this.forwarder = exoPlayerForwarder;
         this.heart = heart;
         this.drmSessionCreator = drmSessionCreator;
-        this.useSecureCodec = useSecureCodec;
+        this.downgradeSecureDecoder = downgradeSecureDecoder;
     }
 
     public void initialise() {
@@ -174,7 +174,7 @@ public void loadVideo(Uri uri, ContentType contentType) {
             reset();
         }
         listenersHolder.getPreparedListeners().resetPreparedState();
-        exoPlayer.loadVideo(drmSessionCreator, uri, contentType, forwarder, useSecureCodec);
+        exoPlayer.loadVideo(drmSessionCreator, uri, contentType, forwarder, downgradeSecureDecoder);
     }
 
     @Override

diff --git a/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerTwoImplFactory.java b/core/src/main/java/com/novoda/noplayer/exoplayer/ExoPlayerTwoImplFactory.java
@@ -20,7 +20,7 @@
 
 public class ExoPlayerTwoImplFactory {
 
-    public ExoPlayerTwoImpl create(Context context, DrmSessionCreator drmSessionCreator, boolean useSecureCodec) {
+    public ExoPlayerTwoImpl create(Context context, DrmSessionCreator drmSessionCreator, boolean downgradeSecureDecoder) {
         DefaultDataSourceFactory defaultDataSourceFactory = new DefaultDataSourceFactory(context, "user-agent");
         Handler handler = new Handler(Looper.getMainLooper());
         MediaSourceFactory mediaSourceFactory = new MediaSourceFactory(defaultDataSourceFactory, handler);
@@ -56,7 +56,7 @@ public ExoPlayerTwoImpl create(Context context, DrmSessionCreator drmSessionCrea
                 loadTimeout,
                 heart,
                 drmSessionCreator,
-                useSecureCodec
+                downgradeSecureDecoder
         );
     }
 }
diff --git a/...oda/noplayer/exoplayer/CodecSelector.java → ...yer/SecurityDowngradingCodecSelector.java b/...oda/noplayer/exoplayer/CodecSelector.java → ...yer/SecurityDowngradingCodecSelector.java
@@ -4,29 +4,25 @@
 import com.google.android.exoplayer2.mediacodec.MediaCodecSelector;
 import com.google.android.exoplayer2.mediacodec.MediaCodecUtil;
 
-/**
- * CodecSelector that allows overriding of the requiresSecureDecoder to allow
- * downgrading of security but not upgrading.
- */
-class CodecSelector implements MediaCodecSelector {
+class SecurityDowngradingCodecSelector implements MediaCodecSelector {
 
     private final InternalMediaCodecUtil internalMediaCodecUtil;
-    private final boolean overrideSecureDecoder;
+    private final boolean downgradeSecureDecoder;
 
-    public static CodecSelector newInstance(boolean useSecureCodec) {
+    public static SecurityDowngradingCodecSelector newInstance(boolean downgradeSecureDecoder) {
         InternalMediaCodecUtil internalMediaCodecUtil = new InternalMediaCodecUtil();
-        return new CodecSelector(internalMediaCodecUtil, useSecureCodec);
+        return new SecurityDowngradingCodecSelector(internalMediaCodecUtil, downgradeSecureDecoder);
     }
 
-    CodecSelector(InternalMediaCodecUtil internalMediaCodecUtil, boolean overrideSecureDecoder) {
+    SecurityDowngradingCodecSelector(InternalMediaCodecUtil internalMediaCodecUtil, boolean downgradeSecureDecoder) {
         this.internalMediaCodecUtil = internalMediaCodecUtil;
-        this.overrideSecureDecoder = overrideSecureDecoder;
+        this.downgradeSecureDecoder = downgradeSecureDecoder;
     }
 
     @Override
     public MediaCodecInfo getDecoderInfo(String mimeType, boolean contentRequiresSecureDecoder)
             throws MediaCodecUtil.DecoderQueryException {
-        return internalMediaCodecUtil.getDecoderInfo(mimeType, contentRequiresSecureDecoder && overrideSecureDecoder);
+        return internalMediaCodecUtil.getDecoderInfo(mimeType, contentRequiresSecureDecoder && !downgradeSecureDecoder);
     }
 
     @Override

diff --git a/core/src/main/java/com/novoda/noplayer/player/PlayerFactory.java b/core/src/main/java/com/novoda/noplayer/player/PlayerFactory.java
@@ -46,22 +46,22 @@ public Player create(DrmType drmType, DrmHandler drmHandler) {
         return create(drmType, drmHandler, USE_SECURE_CODEC);
     }
 
-    public Player create(DrmType drmType, DrmHandler drmHandler, boolean useSecureCodec) {
+    public Player create(DrmType drmType, DrmHandler drmHandler, boolean downgradeSecureDecoder) {
         for (PlayerType player : prioritizedPlayerTypes) {
             if (player.supports(drmType)) {
-                return createPlayerForType(player, drmType, drmHandler, useSecureCodec);
+                return createPlayerForType(player, drmType, drmHandler, downgradeSecureDecoder);
             }
         }
         throw UnableToCreatePlayerException.unhandledDrmType(drmType);
     }
 
-    private Player createPlayerForType(PlayerType playerType, DrmType drmType, DrmHandler drmHandler, boolean useSecureCodec) {
+    private Player createPlayerForType(PlayerType playerType, DrmType drmType, DrmHandler drmHandler, boolean downgradeSecureDecoder) {
         switch (playerType) {
             case MEDIA_PLAYER:
                 return mediaPlayerCreator.createMediaPlayer(context);
             case EXO_PLAYER:
                 DrmSessionCreator drmSessionCreator = drmSessionCreatorFactory.createFor(drmType, drmHandler);
-                return exoPlayerCreator.createExoPlayer(context, drmSessionCreator, useSecureCodec);
+                return exoPlayerCreator.createExoPlayer(context, drmSessionCreator, downgradeSecureDecoder);
             default:
                 throw UnableToCreatePlayerException.unhandledPlayerType(playerType);
         }
@@ -99,8 +99,8 @@ static ExoPlayerCreator newInstance() {
             this.factory = factory;
         }
 
-        Player createExoPlayer(Context context, DrmSessionCreator drmSessionCreator, boolean useSecureCodec) {
-            ExoPlayerTwoImpl player = factory.create(context, drmSessionCreator, useSecureCodec);
+        Player createExoPlayer(Context context, DrmSessionCreator drmSessionCreator, boolean downgradeSecureDecoder) {
+            ExoPlayerTwoImpl player = factory.create(context, drmSessionCreator, downgradeSecureDecoder);
             player.initialise();
             return player;
         }

diff --git a/...noplayer/exoplayer/CodecSelectorTest.java → ...SecurityDowngradingCodecSelectorTest.java b/...noplayer/exoplayer/CodecSelectorTest.java → ...SecurityDowngradingCodecSelectorTest.java
@@ -13,60 +13,60 @@
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.verify;
 
-public class CodecSelectorTest {
+public class SecurityDowngradingCodecSelectorTest {
 
     private static final boolean ANY_USE_SECURE_DECODER = false;
     private static final String ANY_MIME_TYPE = "mimeType";
 
-    private static final boolean OVERRIDE_WITH_SECURE_DECODER = true;
-    private static final boolean OVERRIDE_WITH_INSECURE_DECODER = false;
+    private static final boolean NOT_DOWNGRADING = false;
+    private static final boolean DOWNGRADING = true;
     private static final boolean CONTENT_SECURE = true;
     private static final boolean CONTENT_INSECURE = false;
 
     @Rule
     public MockitoRule mockitoRule = MockitoJUnit.rule();
 
     @Mock
-    private CodecSelector.InternalMediaCodecUtil internalMediaCodecUtil;
+    private SecurityDowngradingCodecSelector.InternalMediaCodecUtil internalMediaCodecUtil;
 
     @Test
-    public void givenContentIsSecure_whenOverridingWithSecure_thenRequiresSecureDecoderIsTrue() throws MediaCodecUtil.DecoderQueryException {
-        CodecSelector codecSelector = new CodecSelector(internalMediaCodecUtil, OVERRIDE_WITH_SECURE_DECODER);
+    public void givenContentIsSecure_whenNotDowngrading_thenRequiresSecureDecoderIsTrue() throws MediaCodecUtil.DecoderQueryException {
+        SecurityDowngradingCodecSelector securityDowngradingCodecSelector = new SecurityDowngradingCodecSelector(internalMediaCodecUtil, NOT_DOWNGRADING);
 
-        codecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_SECURE);
+        securityDowngradingCodecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_SECURE);
 
         ArgumentCaptor<Boolean> argumentCaptor = ArgumentCaptor.forClass(Boolean.class);
         verify(internalMediaCodecUtil).getDecoderInfo(eq(ANY_MIME_TYPE), argumentCaptor.capture());
         assertThat(argumentCaptor.getValue()).isTrue();
     }
 
     @Test
-    public void givenContentIsInsecure_whenOverridingWithInsecure_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
-        CodecSelector codecSelector = new CodecSelector(internalMediaCodecUtil, OVERRIDE_WITH_INSECURE_DECODER);
+    public void givenContentIsInsecure_whenDowngrading_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
+        SecurityDowngradingCodecSelector securityDowngradingCodecSelector = new SecurityDowngradingCodecSelector(internalMediaCodecUtil, DOWNGRADING);
 
-        codecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_INSECURE);
+        securityDowngradingCodecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_INSECURE);
 
         ArgumentCaptor<Boolean> argumentCaptor = ArgumentCaptor.forClass(Boolean.class);
         verify(internalMediaCodecUtil).getDecoderInfo(eq(ANY_MIME_TYPE), argumentCaptor.capture());
         assertThat(argumentCaptor.getValue()).isFalse();
     }
 
     @Test
-    public void givenContentIsSecure_whenOverridingWithInsecure_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
-        CodecSelector codecSelector = new CodecSelector(internalMediaCodecUtil, OVERRIDE_WITH_INSECURE_DECODER);
+    public void givenContentIsSecure_whenDowngrading_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
+        SecurityDowngradingCodecSelector securityDowngradingCodecSelector = new SecurityDowngradingCodecSelector(internalMediaCodecUtil, DOWNGRADING);
 
-        codecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_SECURE);
+        securityDowngradingCodecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_SECURE);
 
         ArgumentCaptor<Boolean> argumentCaptor = ArgumentCaptor.forClass(Boolean.class);
         verify(internalMediaCodecUtil).getDecoderInfo(eq(ANY_MIME_TYPE), argumentCaptor.capture());
         assertThat(argumentCaptor.getValue()).isFalse();
     }
 
     @Test
-    public void givenContentIsInsecure_whenOverridingWithSecure_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
-        CodecSelector codecSelector = new CodecSelector(internalMediaCodecUtil, OVERRIDE_WITH_SECURE_DECODER);
+    public void givenContentIsInsecure_whenNotDowngrading_thenRequiresSecureDecoderIsFalse() throws MediaCodecUtil.DecoderQueryException {
+        SecurityDowngradingCodecSelector securityDowngradingCodecSelector = new SecurityDowngradingCodecSelector(internalMediaCodecUtil, NOT_DOWNGRADING);
 
-        codecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_INSECURE);
+        securityDowngradingCodecSelector.getDecoderInfo(ANY_MIME_TYPE, CONTENT_INSECURE);
 
         ArgumentCaptor<Boolean> argumentCaptor = ArgumentCaptor.forClass(Boolean.class);
         verify(internalMediaCodecUtil).getDecoderInfo(eq(ANY_MIME_TYPE), argumentCaptor.capture());
@@ -75,9 +75,9 @@ public void givenContentIsInsecure_whenOverridingWithSecure_thenRequiresSecureDe
 
     @Test
     public void whenGettingPassthroughDecoderInfo_thenDelegates() throws MediaCodecUtil.DecoderQueryException {
-        CodecSelector codecSelector = new CodecSelector(internalMediaCodecUtil, ANY_USE_SECURE_DECODER);
+        SecurityDowngradingCodecSelector securityDowngradingCodecSelector = new SecurityDowngradingCodecSelector(internalMediaCodecUtil, ANY_USE_SECURE_DECODER);
 
-        codecSelector.getPassthroughDecoderInfo();
+        securityDowngradingCodecSelector.getPassthroughDecoderInfo();
 
         verify(internalMediaCodecUtil).getPassthroughDecoderInfo();
     }