[Cronet] Enable persistence mode for Sdch

components/cronet/android/test/javatests/src/org/chromium/net/SdchTest.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.net;
 
 import android.test.suitebuilder.annotation.SmallTest;
 
+import org.chromium.base.Log;
 import org.chromium.base.test.util.Feature;
 
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
  * Tests Sdch support.
  */
 public class SdchTest extends CronetTestBase {
+    private static final String TAG = Log.makeTag("SdchTest");
     private CronetTestActivity mActivity;
 
     private void setUp(boolean enableSdch) {
-        UrlRequestContextConfig config = new UrlRequestContextConfig();
-        config.enableSDCH(enableSdch);
-        config.setLibraryName("cronet_tests");
-        config.enableHttpCache(UrlRequestContextConfig.HttpCache.IN_MEMORY, 100 * 1024);
-        String[] commandLineArgs = {CronetTestActivity.CONFIG_KEY, config.toString()};
-        mActivity = launchCronetTestAppWithUrlAndCommandLineArgs(null, commandLineArgs);
-        mActivity.startNetLog();
+        List<String> commandLineArgs = new ArrayList<String>();
+        commandLineArgs.add(CronetTestActivity.CACHE_KEY);
+        commandLineArgs.add(CronetTestActivity.CACHE_DISK);
+        if (enableSdch) {
+            commandLineArgs.add(CronetTestActivity.SDCH_KEY);
+            commandLineArgs.add("enable");
+        }
+        String[] args = new String[commandLineArgs.size()];
+        mActivity =
+                launchCronetTestAppWithUrlAndCommandLineArgs(null, commandLineArgs.toArray(args));
 
-        // Registers custom DNS mapping for legacy ChromiumUrlRequestFactory.
         ChromiumUrlRequestFactory factory = (ChromiumUrlRequestFactory) mActivity.mRequestFactory;
-        long legacyAdapter = factory.getRequestContext().getUrlRequestContextAdapterForTesting();
-        assertTrue(legacyAdapter != 0);
-        NativeTestServer.registerHostResolverProc(legacyAdapter, true);
+        registerDNSMapping(factory.getRequestContext().getUrlRequestContextAdapter(), true);
 
-        // Registers custom DNS mapping for CronetUrlRequestContext.
         CronetUrlRequestContext requestContext =
                 (CronetUrlRequestContext) mActivity.mUrlRequestContext;
-        long adapter = requestContext.getUrlRequestContextAdapter();
-        assertTrue(adapter != 0);
-        NativeTestServer.registerHostResolverProc(adapter, false);
+        registerDNSMapping(requestContext.getUrlRequestContextAdapter(), false);
 
-        // Starts NativeTestServer.
+        // Start NativeTestServer.
         assertTrue(NativeTestServer.startNativeTestServer(getInstrumentation().getTargetContext()));
     }
 
     @Override
     protected void tearDown() throws Exception {
         NativeTestServer.shutdownNativeTestServer();
-        mActivity.stopNetLog();
         super.tearDown();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSdchEnabled_LegacyAPI() throws Exception {
         setUp(true);
         // Make a request to /sdch/index which advertises the dictionary.
         TestHttpUrlRequestListener listener1 = startAndWaitForComplete_LegacyAPI(
                 NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
@@ skipping 44 matching lines @@
                 startAndWaitForComplete_LegacyAPI(NativeTestServer.getSdchURL() + "/sdch/test");
         assertEquals(200, listener2.mHttpStatusCode);
         assertEquals("Sdch is not used.\n", listener2.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSdchEnabled() throws Exception {
         setUp(true);
         // Make a request to /sdch which advertises the dictionary.
-        TestUrlRequestListener listener1 =
-                startAndWaitForComplete(NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
+        TestUrlRequestListener listener1 = startAndWaitForComplete(mActivity.mUrlRequestContext,
+                NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
         assertEquals(200, listener1.mResponseInfo.getHttpStatusCode());
         assertEquals("This is an index page.\n", listener1.mResponseAsString);
         assertEquals(Arrays.asList("/sdch/dict/LeQxM80O"),
                 listener1.mResponseInfo.getAllHeaders().get("Get-Dictionary"));
 
         waitForDictionaryAdded("LeQxM80O", false);
 
         // Make a request to fetch encoded response at /sdch/test.
-        TestUrlRequestListener listener2 =
-                startAndWaitForComplete(NativeTestServer.getSdchURL() + "/sdch/test");
-        assertEquals(200, listener1.mResponseInfo.getHttpStatusCode());
+        TestUrlRequestListener listener2 = startAndWaitForComplete(
+                mActivity.mUrlRequestContext, NativeTestServer.getSdchURL() + "/sdch/test");
+        assertEquals(200, listener2.mResponseInfo.getHttpStatusCode());
         assertEquals("The quick brown fox jumps over the lazy dog.\n", listener2.mResponseAsString);
+
+        // Wait for a bit until SimpleCache finished closing entries before
+        // calling shutdown on the UrlRequestContext.
+        // TODO(xunjieli): Remove once crbug.com/486120 is fixed.
+        Thread.sleep(5000);
+        mActivity.mUrlRequestContext.shutdown();
+
+        // Shutting down the context will make JsonPrefStore to flush pending
+        // writes to disk.
+        String dictUrl = NativeTestServer.getSdchURL() + "/sdch/dict/LeQxM80O";
+        assertTrue(prefFileContains("local_prefs.json", dictUrl));
+
+        // Test persistence.
+        CronetUrlRequestContext newContext = new CronetUrlRequestContext(
+                getInstrumentation().getTargetContext(), mActivity.getContextConfig());
+        registerDNSMapping(newContext.getUrlRequestContextAdapter(), false);
+
+        // Wait until dictionaries are reloaded.
+        // FIXME: confirm with Elly where there's a less flaky way.

[xunjieli, 2015/05/11 15:50:41]

FYI. Elly said she might be able to put in a CL to augment SdchObserver, so we
can watch for dictionary add events.

+        Thread.sleep(15000);
+
+        // Make a request to fetch encoded response at /sdch/test.
+        TestUrlRequestListener listener3 =
+                startAndWaitForComplete(newContext, NativeTestServer.getSdchURL() + "/sdch/test");
+        assertEquals(200, listener3.mResponseInfo.getHttpStatusCode());
+        assertEquals("The quick brown fox jumps over the lazy dog.\n", listener3.mResponseAsString);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSdchDisabled() throws Exception {
         setUp(false);
         // Make a request to /sdch.
         // Since Sdch is not enabled, no dictionary should be advertised.
-        TestUrlRequestListener listener =
-                startAndWaitForComplete(NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
+        TestUrlRequestListener listener = startAndWaitForComplete(mActivity.mUrlRequestContext,
+                NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
         assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
         assertEquals("This is an index page.\n", listener.mResponseAsString);
         assertEquals(null, listener.mResponseInfo.getAllHeaders().get("Get-Dictionary"));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testDictionaryNotFound() throws Exception {
         setUp(true);
         // Make a request to /sdch/index which advertises a bad dictionary that
         // does not exist.
-        TestUrlRequestListener listener1 =
-                startAndWaitForComplete(NativeTestServer.getSdchURL() + "/sdch/index?q=NotFound");
+        TestUrlRequestListener listener1 = startAndWaitForComplete(mActivity.mUrlRequestContext,
+                NativeTestServer.getSdchURL() + "/sdch/index?q=NotFound");
         assertEquals(200, listener1.mResponseInfo.getHttpStatusCode());
         assertEquals("This is an index page.\n", listener1.mResponseAsString);
         assertEquals(Arrays.asList("/sdch/dict/NotFound"),
                 listener1.mResponseInfo.getAllHeaders().get("Get-Dictionary"));
 
         waitForDictionaryAdded("NotFound", false);
 
         // Make a request to fetch /sdch/test, and make sure Sdch encoding is not used.
-        TestUrlRequestListener listener2 =
-                startAndWaitForComplete(NativeTestServer.getSdchURL() + "/sdch/test");
+        TestUrlRequestListener listener2 = startAndWaitForComplete(
+                mActivity.mUrlRequestContext, NativeTestServer.getSdchURL() + "/sdch/test");
         assertEquals(200, listener2.mResponseInfo.getHttpStatusCode());
         assertEquals("Sdch is not used.\n", listener2.mResponseAsString);
     }
 
     /**
      * Helper method to wait for dictionary to be fetched and added to the list of available
      * dictionaries.
      */
     private void waitForDictionaryAdded(String dict, boolean isLegacyAPI) throws Exception {
         // Since Http cache is enabled, making a request to the dictionary explicitly will
         // be served from the cache.
         String url = NativeTestServer.getSdchURL() + "/sdch/dict/" + dict;
         if (isLegacyAPI) {
             TestHttpUrlRequestListener listener = startAndWaitForComplete_LegacyAPI(url);
             if (dict.equals("NotFound")) {
                 assertEquals(404, listener.mHttpStatusCode);
             } else {
                 assertEquals(200, listener.mHttpStatusCode);
                 assertTrue(listener.mWasCached);
             }
         } else {
-            TestUrlRequestListener listener = startAndWaitForComplete(url);
+            TestUrlRequestListener listener =
+                    startAndWaitForComplete(mActivity.mUrlRequestContext, url);
             if (dict.equals("NotFound")) {
                 assertEquals(404, listener.mResponseInfo.getHttpStatusCode());
             } else {
                 assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
                 assertTrue(listener.mResponseInfo.wasCached());
             }
         }
         // Now wait for dictionary to be added to the manager, which occurs
         // asynchronously.
         // TODO(xunjieli): Rather than setting an arbitrary delay, consider
         // implementing a SdchObserver to watch for dictionary add events once
         // add event is implemented in SdchObserver.
         Thread.sleep(1000);
     }
 
     private TestHttpUrlRequestListener startAndWaitForComplete_LegacyAPI(String url)
             throws Exception {
         Map<String, String> headers = new HashMap<String, String>();
         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
         HttpUrlRequest request = mActivity.mRequestFactory.createRequest(
                 url, HttpUrlRequest.REQUEST_PRIORITY_MEDIUM, headers, listener);
         request.start();
         listener.blockForComplete();
         return listener;
     }
 
-    private TestUrlRequestListener startAndWaitForComplete(String url) throws Exception {
+    private TestUrlRequestListener startAndWaitForComplete(
+            UrlRequestContext requestContext, String url) throws Exception {
         TestUrlRequestListener listener = new TestUrlRequestListener();
-        UrlRequest request =
-                mActivity.mUrlRequestContext.createRequest(url, listener, listener.getExecutor());
+        UrlRequest request = requestContext.createRequest(url, listener, listener.getExecutor());
         request.start();
         listener.blockForDone();
         return listener;
     }
+
+    // Returns whether a pref file contains a particular string.
+    private boolean prefFileContains(String filename, String content) throws IOException {
+        File prefFile = new File(mActivity.getTestStorage() + "/" + filename);
+        assertTrue(prefFile.exists());
+        boolean contains = false;
+        InputStream in = null;
+        ByteArrayOutputStream out = null;
+        try {
+            in = new FileInputStream(prefFile);

[mef, 2015/05/12 16:39:17]

It seems that canonical way of reading file into string is to use new
BufferedReader(new FileReader(prefFile)):
https://code.google.com/p/chromium/codesearch#chromium/src/net/android/javate...

[xunjieli, 2015/05/12 19:17:50]

Done. That's much cleaner! thanks.

+            out = new ByteArrayOutputStream();
+            int b;
+            while ((b = in.read()) != -1) {
+                out.write(b);
+            }
+            String prefFileContent = out.toString();
+            contains = prefFileContent.contains(content);
+            if (!contains) {
+                Log.i(TAG, "Did not find \"%s\" in file which contains \"%s\"", content,
+                        prefFileContent);
+            }
+        } finally {
+            if (in != null) in.close();
+            if (out != null) out.close();
+        }
+        return contains;
+    }
+
+    // Registers custom DNS mapping for a native UrlRequestContextAdapter object.
+    private void registerDNSMapping(long urlRequestContextAdapter, boolean isLegacyAPI) {
+        assertTrue(urlRequestContextAdapter != 0);
+        NativeTestServer.registerHostResolverProc(urlRequestContextAdapter, isLegacyAPI);
+    }
 }