Use MediaMetadataRetriever.setDataSource(Context, Uri) for "content" scheme.

content/public/android/java/src/org/chromium/content/browser/MediaResourceGetter.java

 // Copyright 2013 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.content.browser;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.media.MediaMetadataRetriever;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
+import android.net.Uri;
 import android.os.ParcelFileDescriptor;
 import android.text.TextUtils;
 
 import org.chromium.base.Log;
 import org.chromium.base.PathUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * Java counterpart of android MediaResourceGetter.
  */
 @JNINamespace("content")
 class MediaResourceGetter {
 
-    private static final String TAG = "cr.MediaResourceGetter";
+    private static final String TAG = "cr_MediaResource";
     private static final MediaMetadata EMPTY_METADATA = new MediaMetadata(0, 0, 0, false);
 
     private final MediaMetadataRetriever mRetriever = new MediaMetadataRetriever();
 
     @VisibleForTesting
     static class MediaMetadata {
         private final int mDurationInMilliseconds;
         private final int mWidth;
         private final int mHeight;
         private final boolean mSuccess;
@@ skipping 141 matching lines @@
                     height = Integer.parseInt(heightString);
                 } catch (NumberFormatException e) {
                     Log.w(TAG, "non-numeric height: %s", heightString);
                     return EMPTY_METADATA;
                 }
             }
             MediaMetadata result = new MediaMetadata(durationMillis, width, height, true);
             Log.d(TAG, "extracted valid metadata: %s", result);
             return result;
         } catch (RuntimeException e) {
-            Log.e(TAG, "Unable to extract metadata: %s", e.getMessage());
+            Log.e(TAG, "Unable to extract metadata: %s", e);
             return EMPTY_METADATA;
         }
     }
 
     @VisibleForTesting
     boolean configure(Context context, String url, String cookies, String userAgent) {
         URI uri;
         try {
             uri = URI.create(url);
         } catch (IllegalArgumentException  e) {
-            Log.e(TAG, "Cannot parse uri: %s", e.getMessage());
+            Log.e(TAG, "Cannot parse uri: %s", e);
             return false;
         }
         String scheme = uri.getScheme();
         if (scheme == null || scheme.equals("file")) {
             File file = uriToFile(uri.getPath());
             if (!file.exists()) {
                 Log.e(TAG, "File does not exist.");
                 return false;
             }
             if (!filePathAcceptable(file, context)) {
                 Log.e(TAG, "Refusing to read from unsafe file location.");
                 return false;
             }
             try {
                 configure(file.getAbsolutePath());
                 return true;
             } catch (RuntimeException e) {
-                Log.e(TAG, "Error configuring data source: %s", e.getMessage());
+                Log.e(TAG, "Error configuring data source: %s", e);
                 return false;
             }
         }
+        if (scheme.equals("content")) {
+            try {
+                configure(context, Uri.parse(uri.toString()));
+                return true;
+            } catch (RuntimeException e) {
+                Log.e(TAG, "Error configuring data source: %s", e);
+                return false;
+            }
+        }
         if (uri.getPath() != null && uri.getPath().endsWith(".m3u8")) {
             // MediaMetadataRetriever does not work with HLS correctly.
             return false;
         }
         final String host = uri.getHost();
         if (!isLoopbackAddress(host) && !isNetworkReliable(context)) {
             Log.w(TAG, "non-file URI can't be read due to unsuitable network conditions");
             return false;
         }
         Map<String, String> headersMap = new HashMap<String, String>();
         if (!TextUtils.isEmpty(cookies)) {
             headersMap.put("Cookie", cookies);
         }
         if (!TextUtils.isEmpty(userAgent)) {
             headersMap.put("User-Agent", userAgent);
         }
         try {
             configure(url, headersMap);
             return true;
         } catch (RuntimeException e) {
-            Log.e(TAG, "Error configuring data source: %s", e.getMessage());
+            Log.e(TAG, "Error configuring data source: %s", e);
             return false;
         }
     }
 
     /**
      * @return true if the device is on an ethernet or wifi network.
      * If anything goes wrong (e.g., permission denied while trying to access
      * the network state), returns false.
      */
     @VisibleForTesting
@@ skipping 128 matching lines @@
     @VisibleForTesting
     void configure(String url, Map<String, String> headers) {
         mRetriever.setDataSource(url, headers);
     }
 
     @VisibleForTesting
     void configure(String path) {
         mRetriever.setDataSource(path);
     }
 
+    void configure(Context context, Uri uri) {

[Ted C, 2016/01/26 21:49:02]

this should be private since it is not used outside of this class.  also, it
seems the others are @VisibleForTesting as they are covered by tests of some
sort.  Should you add a test for this new path?

[horo, 2016/01/27 06:46:57]

Done.
Added unit tests.

+        mRetriever.setDataSource(context, uri);
+    }
+
     @VisibleForTesting
     String extractMetadata(int key) {
         return mRetriever.extractMetadata(key);
     }
 }