remove call to get android MediaPlayer class

media/base/android/java/src/org/chromium/media/MediaPlayerBridge.java

 // Copyright (c) 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.media;
 
 import android.content.Context;
 import android.media.MediaPlayer;
 import android.net.Uri;
 import android.text.TextUtils;
+import android.util.Log;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
+import java.lang.reflect.Method;
 import java.util.HashMap;
 
 @JNINamespace("media")
 class MediaPlayerBridge {
     @CalledByNative
     private static boolean setDataSource(MediaPlayer player, Context context, String url,
             String cookies, boolean hideUrlLog) {
         Uri uri = Uri.parse(url);
         HashMap<String, String> headersMap = new HashMap<String, String>();
         if (hideUrlLog)
             headersMap.put("x-hide-urls-from-log", "true");
         if (!TextUtils.isEmpty(cookies))
             headersMap.put("Cookie", cookies);
         try {
             player.setDataSource(context, uri, headersMap);
             return true;
         } catch (Exception e) {
             return false;
         }
     }
+
+    /**
+     * Returns an array of booleans for allowed operations on the media player.
+     * The first boolean shows whether the player can be paused.
+     * The 2nd boolean shows whether the player can seek forward.
+     * The 3rd boolean shows whether the player can seek backward.

[bulach, 2013/03/13 15:06:10]

the knowledge of which boolean is what is now distributed across two layers, and
the fact that they are positional makes it harder to follow, plus the
documentation can't be enforced. :)
the overhead of letting it be compiled would be fairly minimal, and the
readability would greatly improve...

private static class Metadata {
  private final boolean mCanPause;
  private final boolean mCanSeekForward;
  private final boolean mCanSeekBackward;
  private Metadata(boolean canPause, boolean canSeekForward, boolean
canSeekBackward) {
    mCanPause = canPause;
    mCanSeekForward = canSeekForward;
    mCanSeekBackward = canSeekBackward;
  }

  @CalledByNative
  private boolean canPause() { return mCanPause; }
  @CalledByNative
  private boolean canSeekForward() { return mCanSeekForward; }
  @CalledByNative
  private boolean canSeekBackward() { return mCanSeekBackward; }
}



then in 63-69:
  return new Metadata(..., ..., ...);

then in the native side, just use "Java_Metadata_canSeekForward", etc...
I agree there are slightly more lines of code, but there will be fewer comments
:) and its overhead shouldn't be too significant anyways...

wdyt?

[qinmin, 2013/03/13 18:26:58]

Done.

+     */
+    @CalledByNative
+    private static boolean[] getMetadata(MediaPlayer player) {
+        boolean ret[] = { true, true, true };
+        try {
+            Method getMetadata = player.getClass().getDeclaredMethod(
+                    "getMetadata", boolean.class, boolean.class);
+            getMetadata.setAccessible(true);
+            Object data = getMetadata.invoke(player, false, false);
+            if (data != null) {
+                Class<?> metadataClass = data.getClass();
+                Method hasMethod = metadataClass.getDeclaredMethod("has", int.class);
+                Method getBooleanMethod = metadataClass.getDeclaredMethod("getBoolean", int.class);
+
+                int pause = (Integer) metadataClass.getField("PAUSE_AVAILABLE").get(null);
+                int seekForward =
+                    (Integer) metadataClass.getField("SEEK_FORWARD_AVAILABLE").get(null);
+                int seekBackward =
+                        (Integer) metadataClass.getField("SEEK_BACKWARD_AVAILABLE").get(null);
+                hasMethod.setAccessible(true);
+                getBooleanMethod.setAccessible(true);
+                ret[0] = !((Boolean) hasMethod.invoke(data, pause))
+                         || ((Boolean) getBooleanMethod.invoke(data, pause));
+                ret[1] = !((Boolean) hasMethod.invoke(data, seekForward))
+                         || ((Boolean) getBooleanMethod.invoke(data, seekForward));
+                ret[2] = !((Boolean) hasMethod.invoke(data, seekBackward))
+                         || ((Boolean) getBooleanMethod.invoke(data, seekBackward));
+            }
+        } catch (Exception e) {
+            Log.e("MediaPlayerBridge", "Cannot get metadata from the player: " + e);
+        }
+        return ret;
+    }
 }