android: Fix CanonicalCookie same_site field

chrome/android/java/src/org/chromium/chrome/browser/cookies/CookiesFetcher.java

 // Copyright 2015 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.chrome.browser.cookies;
 
 import android.content.Context;
 import android.os.AsyncTask;
 
 import org.chromium.base.ImportantFileWriterAndroid;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.content.browser.crypto.CipherFactory;
 import org.chromium.content.common.CleanupReference;
 
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.EOFException;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
 import javax.crypto.Cipher;
-import javax.crypto.CipherInputStream;
-import javax.crypto.CipherOutputStream;
 
 /**
  * Responsible for fetching, (de)serializing, and restoring cookies between the CookieJar and an
  * encrypted file storage.
  */
 public class CookiesFetcher {
     /** The default file name for the encrypted cookies storage. */
     private static final String DEFAULT_COOKIE_FILE_NAME = "COOKIES.DAT";
 
     /** Used for logging. */
     private static final String TAG = "CookiesFetcher";
 
-    /**
-     * Used to confirm that the current cipher key matches the previously used cipher key when
-     * restoring data.  If this value cannot be read from the file, the file is likely garbage.
-     * TODO(acleung): May be use real cryptographic integrity checks on the whole file, instead.
-     */
-    private static final String MAGIC_STRING = "c0Ok135";
-
     /** Native-side pointer. */
     private final long mNativeCookiesFetcher;
 
     private final CleanupReference mCleanupReference;
 
     private final Context mContext;
 
     /**
      * Creates a new fetcher that can use to fetch cookies from cookie jar
      * or from a file.
@@ skipping 52 matching lines @@
         } catch (RuntimeException e) {
             e.printStackTrace();
         }
     }
 
     private static void restoreCookiesInternal(final Context context) {
         new AsyncTask<Void, Void, List<CanonicalCookie>>() {
             @Override
             protected List<CanonicalCookie> doInBackground(Void... voids) {
                 // Read cookies from disk on a background thread to avoid strict mode violations.
-                ArrayList<CanonicalCookie> cookies = new ArrayList<CanonicalCookie>();
-                DataInputStream in = null;
+                List<CanonicalCookie> cookies = new ArrayList<CanonicalCookie>();
                 try {
                     Cipher cipher = CipherFactory.getInstance().getCipher(Cipher.DECRYPT_MODE);
                     if (cipher == null) {
                         // Something is wrong. Can't encrypt, don't restore cookies.
                         return cookies;
                     }
+
                     File fileIn = new File(fetchFileName(context));
                     if (!fileIn.exists()) return cookies; // Nothing to read
-
-                    FileInputStream streamIn = new FileInputStream(fileIn);
-                    in = new DataInputStream(new CipherInputStream(streamIn, cipher));
-                    String check = in.readUTF();
-                    if (!MAGIC_STRING.equals(check)) {
-                        // Stale cookie file. Chrome might have crashed before it
-                        // can delete the old file.
-                        return cookies;
-                    }
-                    try {
-                        while (true) {
-                            CanonicalCookie cookie = CanonicalCookie.createFromStream(in);
-                            cookies.add(cookie);
-                        }
-                    } catch (EOFException ignored) {
-                      // We are done.
-                    }
+                    cookies = CanonicalCookie.readFromFileUnknownFormat(fileIn, cipher);
 
                     // The Cookie File should not be restored again. It'll be overwritten
                     // on the next onPause.
                     scheduleDeleteCookiesFile(context);
 
                 } catch (IOException e) {
-                    Log.w(TAG, "IOException during Cookie Restore");
+                    Log.w(TAG, "IOException during Cookie Restore", e);
                 } catch (Throwable t) {
                     Log.w(TAG, "Error restoring cookies.", t);
-                } finally {
-                    try {
-                        if (in != null) in.close();
-                    } catch (IOException e) {
-                        Log.w(TAG, "IOException during Cooke Restore");
-                    } catch (Throwable t) {
-                        Log.w(TAG, "Error restoring cookies.", t);
-                    }
                 }
                 return cookies;
             }
 
             @Override
             protected void onPostExecute(List<CanonicalCookie> cookies) {
                 // We can only access cookies and profiles on the UI thread.
                 for (CanonicalCookie cookie : cookies) {
                     nativeRestoreCookies(cookie.getUrl(), cookie.getName(), cookie.getValue(),
                             cookie.getDomain(), cookie.getPath(), cookie.getCreationDate(),
                             cookie.getExpirationDate(), cookie.getLastAccessDate(),
-                            cookie.isSecure(), cookie.isHttpOnly(), cookie.isSameSite(),
+                            cookie.isSecure(), cookie.isHttpOnly(), cookie.getSameSite(),
                             cookie.getPriority());
                 }
             }
         }.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
     }
 
     /**
      * Ensure the incognito cookies are deleted when the incognito profile is gone.
      *
      * @param context Context for accessing the file system.
@@ skipping 24 matching lines @@
                     }
                 }
                 return null;
             }
         }.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
     }
 
     @CalledByNative
     private CanonicalCookie createCookie(String url, String name, String value, String domain,
             String path, long creation, long expiration, long lastAccess, boolean secure,
-            boolean httpOnly, boolean sameSite, int priority) {
+            boolean httpOnly, int sameSite, int priority) {
         return new CanonicalCookie(url, name, value, domain, path, creation, expiration, lastAccess,
                 secure, httpOnly, sameSite, priority);
     }
 
     @CalledByNative
     private void onCookieFetchFinished(final CanonicalCookie[] cookies) {
         // Cookies fetching requires operations with the profile and must be
         // done in the main thread. Once that is done, do the save to disk
         // part in {@link AsyncTask} to avoid strict mode violations.
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... voids) {
                 saveFetchedCookiesToDisk(cookies);
                 return null;
             }
         }.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
     }
 
     private void saveFetchedCookiesToDisk(CanonicalCookie[] cookies) {
-        DataOutputStream out = null;
         try {
             Cipher cipher = CipherFactory.getInstance().getCipher(Cipher.ENCRYPT_MODE);
             if (cipher == null) {
                 // Something is wrong. Can't encrypt, don't save cookies.
                 return;
             }
 
-            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
-            CipherOutputStream cipherOut =
-                    new CipherOutputStream(byteOut, cipher);
-            out = new DataOutputStream(cipherOut);
-
-            out.writeUTF(MAGIC_STRING);
-            for (CanonicalCookie cookie : cookies) {
-                cookie.saveToStream(out);
-            }
-            out.close();
             ImportantFileWriterAndroid.writeFileAtomically(
-                    fetchFileName(mContext), byteOut.toByteArray());
-            out = null;
+                    fetchFileName(mContext), CanonicalCookie.writeToByteArray(cipher, cookies));
         } catch (IOException e) {
             Log.w(TAG, "IOException during Cookie Fetch");
         } catch (Throwable t) {
             Log.w(TAG, "Error storing cookies.", t);
-        } finally {
-            try {
-                if (out != null) out.close();
-            } catch (IOException e) {
-                Log.w(TAG, "IOException during Cookie Fetch");
-            }
         }
     }
 
     private static final class DestroyRunnable implements Runnable {
         private final long mNativeCookiesFetcher;
 
         private DestroyRunnable(long nativeCookiesFetcher) {
             mNativeCookiesFetcher = nativeCookiesFetcher;
         }
 
         @Override
         public void run() {
             if (mNativeCookiesFetcher != 0) nativeDestroy(mNativeCookiesFetcher);
         }
     }
 
     @CalledByNative
     private CanonicalCookie[] createCookiesArray(int size) {
         return new CanonicalCookie[size];
     }
 
     private native long nativeInit();
     private static native void nativeDestroy(long nativeCookiesFetcher);
     private native void nativePersistCookies(long nativeCookiesFetcher);
     private static native void nativeRestoreCookies(String url, String name, String value,
             String domain, String path, long creation, long expiration, long lastAccess,
-            boolean secure, boolean httpOnly, boolean sameSite, int priority);
+            boolean secure, boolean httpOnly, int sameSite, int priority);
 }