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");
             }
+
             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()) {
             return;
         }
 
         assert mExtractTask != null;
 
@@ skipping 20 matching lines @@
         }
 
         if (shouldSkipPakExtraction()) {
             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());

[Andrew Hayden (chromium.org), 2014/02/21 08:49:39]

This is worse than a warning. If we fail to update ICU, we're may have a very
broken browsing experience, depending upon what we've changed. Correct me if I
am wrong, but doesn't the data file have to be generated by EXACTLY the same
version of the ICU libraries that your code is linked against? What happens if
we upgrade Chrome and this part fails, will all the calls to ICU crash?

There's not really a way around this that I can see at present... but it likely
needs to be an error, not a warning, and depending on the way in which it fails
we might even have to reinstall Chrome to fix it, right?

[benm (inactive), 2014/02/21 13:55:42]

It's a fair point, but I don't think it's any different from failing to remove
the existing PAK files (below, line 333). We could make it a Log.e in both
cases.

Quickly looking over the extraction code, I think we could make this a little
more robust if we also removed the timestamp file when we failed to delete the
resources, that will cause us to try to extract again on next startup (to save
the user uninstalling and re-installing) but I think that improvement is out of
scope for this CL. If that deletion of the timestamp fails ... :-/

[jungshik at Google, 2014/02/21 21:50:49]

What Andrew worries about would not happen often (icudata file is mostly
compatible between versions), but still can happen. 

I'll change both to Log.e. 
I agree that it's out of scope for this CL. And, I might try in another CL, but
I may not be the best person to know all the implications...

+        }
         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.
      */
     private static boolean shouldSkipPakExtraction() {
         // Must call setMandatoryPaksToExtract before beginning resource extraction.
         assert sMandatoryPaks != null;
         return sMandatoryPaks.length == 1 && "".equals(sMandatoryPaks[0]);
     }
 }