Remove static PACKAGE_NAME variable and refactor getRawAcceptableDirectories method.

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.content.Context;
 import android.content.pm.PackageManager;
 import android.media.MediaMetadataRetriever;
 import android.net.ConnectivityManager;
@@ skipping 20 matching lines @@
  * Java counterpart of android MediaResourceGetter.
  */
 @JNINamespace("content")
 class MediaResourceGetter {
 
     private static final String TAG = "MediaResourceGetter";
     private static final MediaMetadata EMPTY_METADATA = new MediaMetadata(0,0,0,false);
 
     private final MediaMetadataRetriever mRetriever = new MediaMetadataRetriever();
 
-    private static String PACKAGE_NAME = null;
-
     @VisibleForTesting
     static class MediaMetadata {
         private final int mDurationInMilliseconds;
         private final int mWidth;
         private final int mHeight;
         private final boolean mSuccess;
 
         MediaMetadata(int durationInMilliseconds, int width, int height, boolean success) {
             mDurationInMilliseconds = durationInMilliseconds;
             mWidth = width;
@@ skipping 56 matching lines @@
                 return false;
             return true;
         }
     }
 
     @CalledByNative
     private static MediaMetadata extractMediaMetadata(final Context context,
                                                       final String url,
                                                       final String cookies,
                                                       final String userAgent) {
-        PACKAGE_NAME = context.getPackageName();
         return new MediaResourceGetter().extract(
                 context, url, cookies, userAgent);
     }
 
     @CalledByNative
     private static MediaMetadata extractMediaMetadataFromFd(int fd,
                                                             long offset,
                                                             long length) {
         return new MediaResourceGetter().extract(fd, offset, length);
     }
@@ skipping 89 matching lines @@
             Log.e(TAG, "Cannot parse uri.", 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)) {
+            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", e);
                 return false;
             }
@@ skipping 58 matching lines @@
                 || host.equals("127.0.0.1")  // typical IP v4 expression
                 || host.equals("[::1]"));  // typical IP v6 expression
     }
 
     /**
      * @param file the file whose path should be checked
      * @return true if and only if the file is in a location that we consider
      * safe to read from, such as /mnt/sdcard.
      */
     @VisibleForTesting
-    boolean filePathAcceptable(File file) {
+    boolean filePathAcceptable(File file, Context context) {
         final String path;
         try {
             path = file.getCanonicalPath();
         } catch (IOException e) {
             // Canonicalization has failed. Assume malicious, give up.
             Log.w(TAG, "canonicalization of file path failed");
             return false;
         }
         // In order to properly match the roots we must also canonicalize the
         // well-known paths we are matching against. If we don't, then we can
         // get unusual results in testing systems or possibly on rooted devices.
         // Note that canonicalized directory paths always end with '/'.
-        List<String> acceptablePaths = canonicalize(getRawAcceptableDirectories());
+        List<String> acceptablePaths = canonicalize(getRawAcceptableDirectories(context));
         acceptablePaths.add(getExternalStorageDirectory());
         Log.d(TAG, "canonicalized file path: " + path);
         for (String acceptablePath : acceptablePaths) {
             if (path.startsWith(acceptablePath)) {
                 return true;
             }
         }
         return false;
     }
 
@@ skipping 25 matching lines @@
             return null;
         }
         NetworkInfo info = mConnectivityManager.getActiveNetworkInfo();
         if (info == null) {
             Log.d(TAG, "no active network");
             return null;
         }
         return info.getType();
     }
 
-    private List<String> getRawAcceptableDirectories() {
+    private List<String> getRawAcceptableDirectories(Context context) {
         List<String> result = new ArrayList<String>();
         result.add("/mnt/sdcard/");
         result.add("/sdcard/");
-        if (PACKAGE_NAME != null)
-            result.add("/data/data/" + PACKAGE_NAME + "/cache/");
+        result.add("/data/data/" + context.getPackageName() + "/cache/");
         return result;
     }
 
     private List<String> canonicalize(List<String> paths) {
         List<String> result = new ArrayList<String>(paths.size());
         try {
             for (String path : paths) {
                 result.add(new File(path).getCanonicalPath());
             }
             return result;
@@ skipping 32 matching lines @@
     @VisibleForTesting
     void configure(String path) {
         mRetriever.setDataSource(path);
     }
 
     @VisibleForTesting
     String extractMetadata(int key) {
         return mRetriever.extractMetadata(key);
     }
 }