Enable icu_use_data_file_flag on Android

content/public/android/java/src/org/chromium/content/browser/ResourceExtractor.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.content.browser;
 
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
@@ skipping 18 matching lines @@
 
 /**
  * Handles extracting the necessary resources bundled in an APK and moving them to a location on
  * the file system accessible from the native code.
  */
 public class ResourceExtractor {
 
     private static final String LOGTAG = "ResourceExtractor";
     private static final String LAST_LANGUAGE = "Last language";
     private static final String PAK_FILENAMES = "Pak filenames";
+    private static final String ICU_DATA_FILENAME = "icudtl.dat";
 
     private static String[] sMandatoryPaks = null;
 
     // By default, we attempt to extract a pak file for the users
     // current device locale. Use setExtractImplicitLocale() to
     // change this behavior.
     private static boolean sExtractImplicitLocalePak = true;
 
     private class ExtractTask extends AsyncTask<Void, Void, Void> {
         private static final int BUFFER_SIZE = 16 * 1024;
@@ skipping 40 matching lines @@
             }
 
             if (sExtractImplicitLocalePak) {
                 if (p.length() > 0) p.append('|');
                 // As well as the minimum required set of .paks above, we'll also add all .paks that
                 // we have for the user's currently selected language.
 
                 p.append(currentLanguage);
                 p.append("(-\\w+)?\\.pak");
             }
+
+            if (p.length() > 0) p.append('|');
+            p.append(ICU_DATA_FILENAME);
+
             Pattern paksToInstall = Pattern.compile(p.toString());
 
             AssetManager manager = mContext.getResources().getAssets();
             try {
                 // Loop through every asset file that we have in the APK, and look for the
                 // ones that we need to extract by trying to match the Patterns that we
                 // created above.
                 byte[] buffer = null;
                 String[] files = manager.list("");
                 for (String file : files) {
                     if (!paksToInstall.matcher(file).matches()) {
                         continue;
                     }
-                    File output = new File(mOutputDir, file);
+                    boolean isICUData = file.equals(ICU_DATA_FILENAME);
+                    File output = new File(isICUData ? mAppDataDir : mOutputDir, file);
                     if (output.exists()) {
                         continue;
                     }
 
                     InputStream is = null;
                     OutputStream os = null;
                     try {
                         is = manager.open(file);
                         os = new FileOutputStream(output);
                         Log.i(LOGTAG, "Extracting resource " + file);
                         if (buffer == null) {
                             buffer = new byte[BUFFER_SIZE];
                         }
 
                         int count = 0;
                         while ((count = is.read(buffer, 0, BUFFER_SIZE)) != -1) {
                             os.write(buffer, 0, count);
                         }
                         os.flush();
 
                         // Ensure something reasonable was written.
                         if (output.length() == 0) {
                             throw new IOException(file + " extracted with 0 length!");
                         }
 
-                        filenames.add(file);
+                        if (!isICUData) {
+                            filenames.add(file);
+                        } else {
+                            // icudata needs to be accessed by a renderer process.
+                            output.setReadable(true, false);
+                        }
                     } finally {
                         try {
                             if (is != null) {
                                 is.close();
                             }
                         } finally {
                             if (os != null) {
                                 os.close();
                             }
                         }
@@ skipping 67 matching lines @@
                 return expectedTimestamp;
             }
 
             // timestamp file is already up-to date.
             return null;
         }
     }
 
     private final Context mContext;
     private ExtractTask mExtractTask;
+    private final File mAppDataDir;
     private final File mOutputDir;
 
     private static ResourceExtractor sInstance;
 
     public static ResourceExtractor get(Context context) {
         if (sInstance == null) {
             sInstance = new ResourceExtractor(context);
         }
         return sInstance;
     }
@@ skipping 20 matching lines @@
      *         pak files specified in sMandatoryPaks.
      */
     public static void setExtractImplicitLocaleForTesting(boolean extract) {
         assert (sInstance == null || sInstance.mExtractTask == null)
                 : "Must be called before startExtractingResources is called";
         sExtractImplicitLocalePak = extract;
     }
 
     private ResourceExtractor(Context context) {
         mContext = context;
+        mAppDataDir = getAppDataDirFromContext(mContext);
         mOutputDir = getOutputDirFromContext(mContext);
     }
 
     public void waitForCompletion() {
-        if (shouldSkipPakExtraction()) {
+        if (shouldSkipExtraction()) {
             return;
         }
 
         assert mExtractTask != null;
 
         try {
             mExtractTask.get();
         } catch (CancellationException e) {
             // Don't leave the files in an inconsistent state.
             deleteFiles(mContext);
         } catch (ExecutionException e2) {
             deleteFiles(mContext);
         } catch (InterruptedException e3) {
             deleteFiles(mContext);
         }
     }
 
     /**
      * This will extract the application pak resources in an
      * AsyncTask. Call waitForCompletion() at the point resources
      * are needed to block until the task completes.
      */
     public void startExtractingResources() {
         if (mExtractTask != null) {
             return;
         }
 
-        if (shouldSkipPakExtraction()) {
+        if (shouldSkipExtraction()) {
             return;
         }
 
         mExtractTask = new ExtractTask();
         mExtractTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
+    public static File getAppDataDirFromContext(Context context) {
+        return new File(PathUtils.getDataDirectory(context.getApplicationContext()));
+    }
     public static File getOutputDirFromContext(Context context) {
-        return new File(PathUtils.getDataDirectory(context.getApplicationContext()), "paks");
+        return new File(getAppDataDirFromContext(context), "paks");
     }
 
     public static void deleteFiles(Context context) {
+        File icudata = new File(getAppDataDirFromContext(context), ICU_DATA_FILENAME);
+        if (icudata.exists() && !icudata.delete()) {
+            Log.w(LOGTAG, "Unable to remove the icudata " + icudata.getName());
+        }
         File dir = getOutputDirFromContext(context);
         if (dir.exists()) {
             File[] files = dir.listFiles();
             for (File file : files) {
                 if (!file.delete()) {
                     Log.w(LOGTAG, "Unable to remove existing resource " + file.getName());
                 }
             }
         }
     }
 
     /**
      * Pak extraction not necessarily required by the embedder; we allow them to skip
-     * this process if they call setMandatoryPaksToExtract with a single empty String.
+     * this process if they call setMandatoryPaksToExtract with a single empty String and the
+     * icudata is absent. icudtl.dat will be present only when icu_use_data_file_flag == 1, which is
+     * false for the WebView build.

[benm (inactive), 2014/02/10 21:30:45]

i think that if an app using WebView had bundled a file called icudtl.dat that
we'd now extract this to it's data directory?

Also, I think that looking into the AssetManager might be slow (although I don't
have data to back that up), and this happens on the critical app start up path.
Would it be better to set a flag to say if we should extract ICU data, like we
set the mandatory paks? Maybe we just have MANDATORY_RESOURCES that combines the
needed PAKs and other files? we could still do the check on the filename when we
extract above to put the ICU file into the correct place.

[jungshik at Google, 2014/02/10 22:10:31]

Although that's not likely, I agree that we'd better be on the safe side. 
I'm less worried about the performance than about your 1st concern (although I'm
just a novice here and I may as well completely wrong) given that line 116 uses
AssetManager to list all the files in APK. 

There are 5 files specifying MANDATORY_PAKS ( http://goo.gl/KgHvhZ ). Are they
all non-webview stadalone targets? Then, I have to add icudtl.dat to all 5 of
them. 

[benm (inactive), 2014/02/10 22:28:32]

I think that the other use will only happen in the case that PAK extraction is
actually required, which should be only the first time after a new install or
update. I think this new check will happen on every start up regardless?
Yes, they are all non-WebView. They all look like test runners - do they all
require the ICU data file? 

[jungshik at Google, 2014/02/10 23:41:46]

That's what I expect us to do, but my reading of the current code (lines 106 ~
125) is that every time it starts, AssetManager is called to get the list of all
the files in assets/, match the list against 'pattern' and check their existence
in the target directory (if exist / already copied/extreacted, do not
copy/extract). 
Am I misreading it? 
Anything that renders web pages need the icudata unless we use the 'system icu'
(ICU from Android), which is the case of WebView. ICU is used also in the
UI/browser process. 

BTW, is this also non-webview?  

android_webview/test/shell/src/org/chromium/android_webview/shell/AwShellApplication.java

      */
+    private boolean shouldSkipExtraction() {
+        AssetManager manager = mContext.getResources().getAssets();
+        String[] files = null;
+        try {
+            files = manager.list(ICU_DATA_FILENAME);
+        } catch (IOException e) {
+            Log.w(LOGTAG, ICU_DATA_FILENAME + " is not found.");
+        }
+        return (files == null) && shouldSkipPakExtraction();
+    }
+
     private static boolean shouldSkipPakExtraction() {
         // Must call setMandatoryPaksToExtract before beginning resource extraction.
         assert sMandatoryPaks != null;
         return sMandatoryPaks.length == 1 && "".equals(sMandatoryPaks[0]);
     }
 }