[Cronet] Purge storage directory if version does not match

components/cronet/android/test/javatests/src/org/chromium/net/DiskCacheTest.java

Index: components/cronet/android/test/javatests/src/org/chromium/net/DiskCacheTest.java
diff --git a/components/cronet/android/test/javatests/src/org/chromium/net/DiskCacheTest.java b/components/cronet/android/test/javatests/src/org/chromium/net/DiskCacheTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..527fde16586a1e3e5db3b2564cc62c7c69d7a8eb
--- /dev/null
+++ b/components/cronet/android/test/javatests/src/org/chromium/net/DiskCacheTest.java
@@ -0,0 +1,139 @@
+// Copyright 2016 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.net;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.test.util.Feature;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.util.Arrays;
+
+/**
+ * Test CronetEngine disk cache.
+ */
+public class DiskCacheTest extends CronetTestBase {

[mef, 2016/04/01 21:16:03]

Maybe rename DiskCacheTest -> DiskStorageTest?

I wonder whether we should add a test for when storage path is set to readonly
directory (It checks that directory exists, so at least name is valid). 

I wouldn't be surprised if it will break, but I wouldn't be surprised if it
breaks without this change as well.

[xunjieli, 2016/04/04 15:01:24]

Done. The directory is initialized as normal. The test instrumentation has the
same UID as the test app, so I guess setting the directory to readOnly doesn't
do much. The test has no permission to set a directory in external storage
(sdcard) to readOnly, so I didn't use that.

[mef, 2016/04/05 18:00:50]

Acknowledged.

+    CronetTestFramework mTestFramework;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        System.loadLibrary("cronet_tests");
+        assertTrue(NativeTestServer.startNativeTestServer(getContext()));
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        NativeTestServer.shutdownNativeTestServer();
+        super.tearDown();
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    public void testPurgeOldVersion() throws Exception {
+        String testStorage = CronetTestFramework.getTestStorage(getContext());
+        File versionFile = new File(testStorage + "/version");
+        FileOutputStream versionOut = null;
+        try {
+            versionOut = new FileOutputStream(versionFile);
+            versionOut.write(new byte[] {2, 0, 0, 0}, 0, 4);

[mef, 2016/04/01 21:16:03]

this is actually newer version, right? So, if we increment version at some
point, then this will break.

[xunjieli, 2016/04/04 15:01:24]

Done.

+        } finally {
+            if (versionOut != null) {
+                versionOut.close();
+            }
+        }
+        File oldPrefsFile = new File(testStorage + "/local_prefs.json");
+        FileOutputStream oldPrefsOut = null;
+        try {
+            oldPrefsOut = new FileOutputStream(oldPrefsFile);
+            String dummy = "dummy content";
+            oldPrefsOut.write(dummy.getBytes(), 0, dummy.length());
+        } finally {
+            if (oldPrefsOut != null) {
+                oldPrefsOut.close();
+            }
+        }
+
+        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        builder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
+        builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, 1024 * 1024);
+
+        mTestFramework = new CronetTestFramework(null, null, getContext(), builder);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        String url = NativeTestServer.getFileURL("/cacheable.txt");
+        UrlRequest.Builder requestBuilder = new UrlRequest.Builder(
+                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest urlRequest = requestBuilder.build();
+        urlRequest.start();
+        callback.blockForDone();
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        mTestFramework.mCronetEngine.shutdown();
+        FileInputStream newVersionFile = null;
+        try {
+            newVersionFile = new FileInputStream(versionFile);
+            byte[] buffer = new byte[] {0, 0, 0, 0};
+            int bytesRead = newVersionFile.read(buffer, 0, 4);
+            assertEquals(4, bytesRead);
+            assertTrue(Arrays.equals(new byte[] {1, 0, 0, 0}, buffer));
+        } finally {
+            if (newVersionFile != null) {
+                newVersionFile.close();
+            }
+        }
+        oldPrefsFile = new File(testStorage + "/local_prefs.json");
+        assertTrue(!oldPrefsFile.exists());
+    }
+
+    @SmallTest
+    @Feature({"Cronet"})
+    @OnlyRunNativeCronet
+    // Tests that if cache version is current, Cronet does not purge the
+    // directory.
+    public void testCacheVersionCurrent() throws Exception {
+        String testStorage = CronetTestFramework.getTestStorage(getContext());
+        File versionFile = new File(testStorage + "/version");
+        FileOutputStream versionOut = null;
+        try {
+            versionOut = new FileOutputStream(versionFile);
+            versionOut.write(new byte[] {1, 0, 0, 0}, 0, 4);

[mef, 2016/04/01 21:16:03]

This looks very brittle as it depends on actual format and content of version
file. 

Can we do this:

1. initialize the storage, 
2. shutdown the engine, 
3. create the dummy file,
4. create another engine,
5. verify that it doesn't delete the dummy file?

[xunjieli, 2016/04/04 15:01:24]

Done.

+        } finally {
+            if (versionOut != null) {
+                versionOut.close();
+            }
+        }
+        File dir = new File(testStorage + "/random");
+        assertTrue(dir.mkdir());
+        File dummyFile = new File(testStorage + "/random/dummy.json");
+        FileOutputStream dummyFileOut = null;
+        try {
+            dummyFileOut = new FileOutputStream(dummyFile);
+            String dummy = "dummy content";
+            dummyFileOut.write(dummy.getBytes(), 0, dummy.length());
+        } finally {
+            if (dummyFileOut != null) {
+                dummyFileOut.close();
+            }
+        }
+
+        CronetEngine.Builder builder = new CronetEngine.Builder(getContext());
+        builder.setStoragePath(CronetTestFramework.getTestStorage(getContext()));
+        builder.enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, 1024 * 1024);
+
+        mTestFramework = new CronetTestFramework(null, null, getContext(), builder);
+        TestUrlRequestCallback callback = new TestUrlRequestCallback();
+        String url = NativeTestServer.getFileURL("/cacheable.txt");
+        UrlRequest.Builder requestBuilder = new UrlRequest.Builder(
+                url, callback, callback.getExecutor(), mTestFramework.mCronetEngine);
+        UrlRequest urlRequest = requestBuilder.build();
+        urlRequest.start();
+        callback.blockForDone();
+        assertEquals(200, callback.mResponseInfo.getHttpStatusCode());
+        mTestFramework.mCronetEngine.shutdown();
+        assertTrue(dummyFile.exists());
+    }
+}