android: Fix CanonicalCookie same_site field

chrome/android/java/src/org/chromium/chrome/browser/cookies/CanonicalCookie.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 java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 /**
  * Java representation of net/cookies/canonical_cookie.h.
  */
 class CanonicalCookie {
     private final String mUrl;
     private final String mName;
     private final String mValue;
     private final String mDomain;
     private final String mPath;
     private final long mCreation;
     private final long mExpiration;
     private final long mLastAccess;
     private final boolean mSecure;
     private final boolean mHttpOnly;
-    private final boolean mSameSite;
+    private final int mSameSite;
     private final int mPriority;
 
     /** Constructs a CanonicalCookie */
     CanonicalCookie(String url, String name, String value, String domain, String path,
             long creation, long expiration, long lastAccess, boolean secure, boolean httpOnly,
-            boolean sameSite, int priority) {
+            int sameSite, int priority) {
         mUrl = url;
         mName = name;
         mValue = value;
         mDomain = domain;
         mPath = path;
         mCreation = creation;
         mExpiration = expiration;
         mLastAccess = lastAccess;
         mSecure = secure;
         mHttpOnly = httpOnly;
         mSameSite = sameSite;
         mPriority = priority;
     }
 
     /** @return Priority of the cookie. */
     int getPriority() {
         return mPriority;
     }
 
     /** @return True if the cookie is HTTP only. */
     boolean isHttpOnly() {
         return mHttpOnly;
     }
 
-    /** @return True if the cookie is Same-Site. */
-    boolean isSameSite() {
+    /** @return SameSite enum */
+    int getSameSite() {
         return mSameSite;
     }
 
     /** @return True if the cookie is secure. */
     boolean isSecure() {
         return mSecure;
     }
 
     /** @return Last accessed time. */
     long getLastAccessDate() {
@@ skipping 45 matching lines @@
         out.writeUTF(mUrl);
         out.writeUTF(mName);
         out.writeUTF(mValue);
         out.writeUTF(mDomain);
         out.writeUTF(mPath);
         out.writeLong(mCreation);
         out.writeLong(mExpiration);
         out.writeLong(mLastAccess);
         out.writeBoolean(mSecure);
         out.writeBoolean(mHttpOnly);
-        out.writeBoolean(mSameSite);
+        out.writeInt(mSameSite);

[boliu, 2016/04/18 20:50:22]

this should be safe since CookiesFetcher catches Throwable to make sure it
doesn't crash..?

[Yaron, 2016/04/19 14:36:13]

Confused why you're worried about the write - it's the read of the old boolean
as int which would be my concern. :)
Now you'd be trying to read 2 ints instead of a boolean & an int so the second
int will hit EOF. What's worse is that there's no separator between canonical
cookies so you'll actually start reading into the next canonical cookies's data
and you'd be off alignment and reading grabage :S

The safest thing may be to blow away the cookie store as a one-time operation
for this migration and add a version # to allow future upgrades to be seamless?

         out.writeInt(mPriority);
     }
 
     /**
      * Constructs a cookie by deserializing a single entry from the
      * input stream.
      *
      * @param in Stream to read a cookie entry from.
      */
     static CanonicalCookie createFromStream(DataInputStream in)
             throws IOException {
         return new CanonicalCookie(in.readUTF(), in.readUTF(), in.readUTF(), in.readUTF(),
                 in.readUTF(), in.readLong(), in.readLong(), in.readLong(), in.readBoolean(),
-                in.readBoolean(), in.readBoolean(), in.readInt());
+                in.readBoolean(), in.readInt(), in.readInt());
     }
 }