Remove uses of deprecated Header class

chrome/android/java/src/org/chromium/chrome/browser/media/remote/DefaultMediaRouteController.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.media.remote;
 
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.support.v7.media.MediaControlIntent;
 import android.support.v7.media.MediaItemMetadata;
 import android.support.v7.media.MediaItemStatus;
 import android.support.v7.media.MediaRouteSelector;
 import android.support.v7.media.MediaRouter;
 import android.support.v7.media.MediaRouter.RouteInfo;
 import android.support.v7.media.MediaSessionStatus;
 import android.util.Log;
 import android.widget.Toast;
 
 import com.google.android.gms.cast.CastMediaControlIntent;
 
-import org.apache.http.Header;
 import org.chromium.base.ApplicationState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.CommandLine;
 import org.chromium.chrome.ChromeSwitches;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.media.remote.RemoteVideoInfo.PlayerState;
 
 import java.net.URI;
 import java.net.URISyntaxException;
 
@@ skipping 48 matching lines @@
         void onError(String message, Bundle data);
     }
 
     private static final String TAG = "DefaultMediaRouteController";
 
     private static final String ACTION_RECEIVE_SESSION_STATUS_UPDATE =
             "com.google.android.apps.chrome.videofling.RECEIVE_SESSION_STATUS_UPDATE";
     private static final String ACTION_RECEIVE_MEDIA_STATUS_UPDATE =
             "com.google.android.apps.chrome.videofling.RECEIVE_MEDIA_STATUS_UPDATE";
     private static final String MIME_TYPE = "video/mp4";
-
     private boolean mDebug;
     private String mCurrentSessionId;
     private String mCurrentItemId;
     private int mStreamPositionTimestamp;
     private int mLastKnownStreamPosition;
     private int mStreamDuration;
     private boolean mSeeking;
     private final String mIntentCategory;
     private PendingIntent mSessionStatusUpdateIntent;
     private BroadcastReceiver mSessionStatusBroadcastReceiver;
     private PendingIntent mMediaStatusUpdateIntent;
     private BroadcastReceiver mMediaStatusBroadcastReceiver;
     private boolean mReconnecting = false;
 
     private Uri mVideoUriToStart;
     private String mPreferredTitle;
     private long mStartPositionMillis;
 
     private Uri mLocalVideoUri;
 
     private String mLocalVideoCookies;
 
     private MediaUrlResolver mMediaUrlResolver;
 
     private int mSessionState = MediaSessionStatus.SESSION_STATE_INVALIDATED;
 
-    // Media types supported for cast, see
-    // media/base/container_names.h for the actual enum where these are defined
-    private static final int UNKNOWN_MEDIA = 0;
-    private static final int SMOOTHSTREAM_MEDIA = 39;
-    private static final int DASH_MEDIA = 38;
-    private static final int HLS_MEDIA = 22;
-    private static final int MPEG4_MEDIA = 29;
-
     private final ApplicationStatus.ApplicationStateListener
             mApplicationStateListener = new ApplicationStatus.ApplicationStateListener() {
                 @Override
                 public void onApplicationStateChange(int newState) {
                     switch (newState) {
                     // HAS_DESTROYED_ACTIVITIES means all Chrome activities have been destroyed.
                         case ApplicationState.HAS_DESTROYED_ACTIVITIES:
                             onActivitiesDestroyed();
                             break;
                         default:
                             break;
                     }
                 }
             };
 
     private final MediaUrlResolver.Delegate
             mMediaUrlResolverDelegate = new MediaUrlResolver.Delegate() {
                 @Override
                 public Uri getUri() {
                     return mLocalVideoUri;
                 }
 
                 @Override
                 public String getCookies() {
                     return mLocalVideoCookies;
                 }
 
                 @Override
-                public void setUri(Uri uri, Header[] headers) {
-                    if (canPlayMedia(uri, headers)) {
+                public void setUri(Uri uri, boolean playable) {
+                    if (playable) {
                         mLocalVideoUri = uri;
                         playMedia();
                         return;
                     }
                     mLocalVideoUri = null;
                     showMessageToast(
                             getContext().getString(R.string.cast_permission_error_playing_video));
                     release();
                 }
             };
@@ skipping 198 matching lines @@
      * Plays the given Uri on the currently selected player. This will replace any currently playing
      * video
      *
      * @param videoUri Uri of the video to play
      * @param preferredTitle the preferred title of the current playback session to display
      * @param startPositionMillis from which to start playing.
      */
     private void playUri(final Uri videoUri,
             @Nullable final String preferredTitle, final long startPositionMillis) {
 
-        RecordCastAction.castMediaType(getMediaType(videoUri));
+        RecordCastAction.castMediaType(MediaUrlResolver.getMediaType(videoUri.toString()));
         installBroadcastReceivers();
 
         // Check if we are reconnecting or have reconnected and are playing the same video
         if ((mReconnecting || mCurrentSessionId != null)
                 && videoUri.toString().equals(RemotePlaybackSettings.getUriPlaying(getContext()))) {
             return;
         }
 
         // If the session is already started (meaning we are casting a video already), we simply
         // load the new URL with one ACTION_PLAY intent.
@@ skipping 650 matching lines @@
         if (mMediaUrlResolver != null) mMediaUrlResolver.cancel(true);
 
         // Create a new MediaUrlResolver since the previous one may still be running despite the
         // cancel() call.
         mMediaUrlResolver = new MediaUrlResolver(getContext(), mMediaUrlResolverDelegate);
 
         mStartPositionMillis = startPositionMillis;
         mMediaUrlResolver.execute();
     }
 
-    private boolean canPlayMedia(Uri uri, Header[] headers) {
-        if (uri == Uri.EMPTY) return false;
-
-        // HLS media requires Cors headers. Since these are the only ones
-        // sent now we can just check that headers is not empty but
-        // if more headers are added we should be more strict in the check.
-        if ((headers == null || headers.length == 0) && isEnhancedMedia(uri)) {
-            if (mDebug) Log.d(TAG, "HLS stream without CORs header: " + uri);
-            return false;
-        }
-        return true;
-    }
-
     private void playMedia() {
         String title = getMediaStateListener().getTitle();
         playUri(mLocalVideoUri, title, mStartPositionMillis);
     }
 
     private void showMessageToast(String message) {
         Toast toast = Toast.makeText(getContext(), message, Toast.LENGTH_SHORT);
         toast.show();
     }
 
     private void configureNewSession(Bundle data) {
         mCurrentSessionId = data.getString(MediaControlIntent.EXTRA_SESSION_ID);
         mSessionState = MediaSessionStatus.SESSION_STATE_INVALIDATED;
         RemotePlaybackSettings.setSessionId(getContext(), mCurrentSessionId);
         if (mDebug) Log.d(TAG, "Got a session id: " + mCurrentSessionId);
     }
-
-    private int getMediaType(Uri videoUri) {
-        String uriString = videoUri.toString();
-        if (uriString.contains(".m3u8")) {
-            return HLS_MEDIA;
-        }
-        if (uriString.contains(".mp4")) {
-            return MPEG4_MEDIA;
-        }
-        if (uriString.contains(".mpd")) {
-            return DASH_MEDIA;
-        }
-        if (uriString.contains(".ism")) {
-            return SMOOTHSTREAM_MEDIA;
-        }
-        return UNKNOWN_MEDIA;
-    }
-
-    private boolean isEnhancedMedia(Uri videoUri) {
-        int mediaType = getMediaType(videoUri);
-        return mediaType == HLS_MEDIA || mediaType == DASH_MEDIA || mediaType == SMOOTHSTREAM_MEDIA;
-    }
 }