[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.os.ConditionVariable;
 import android.test.suitebuilder.annotation.SmallTest;
 
+import org.chromium.base.Log;
 import org.chromium.base.test.util.Feature;
+import org.chromium.net.SdchTestUtil.SdchObserverCallback;
 
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+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();
+    private enum SDCH {
+        ENABLED,
+        DISABLED,
+    }
 
-        // Registers custom DNS mapping for legacy ChromiumUrlRequestFactory.
-        ChromiumUrlRequestFactory factory = (ChromiumUrlRequestFactory) mActivity.mRequestFactory;
-        long legacyAdapter = factory.getRequestContext().getUrlRequestContextAdapterForTesting();
-        assertTrue(legacyAdapter != 0);
-        NativeTestServer.registerHostResolverProc(legacyAdapter, true);
+    private enum API {
+        LEGACY,
+        ASYNC,
+    }
 
-        // Registers custom DNS mapping for CronetUrlRequestContext.
-        CronetUrlRequestContext requestContext =
-                (CronetUrlRequestContext) mActivity.mUrlRequestContext;
-        long adapter = requestContext.getUrlRequestContextAdapter();
-        assertTrue(adapter != 0);
-        NativeTestServer.registerHostResolverProc(adapter, false);
+    private void setUp(SDCH setting, API api) {
+        List<String> commandLineArgs = new ArrayList<String>();
+        commandLineArgs.add(CronetTestActivity.CACHE_KEY);
+        commandLineArgs.add(CronetTestActivity.CACHE_DISK);
+        if (setting == SDCH.ENABLED) {
+            commandLineArgs.add(CronetTestActivity.SDCH_KEY);
+            commandLineArgs.add("enable");

[mmenke, 2015/05/20 18:33:41]

?

[xunjieli, 2015/05/20 21:06:12]

Done. Refactored to make the value into a static variable so it's clearer.

+        }
 
-        // Starts NativeTestServer.
+        String[] args = new String[commandLineArgs.size()];
+        mActivity =
+                launchCronetTestAppWithUrlAndCommandLineArgs(null, commandLineArgs.toArray(args));
+        long urlRequestContextAdapter = (api == API.LEGACY)
+                ? getRequestAdapter((ChromiumUrlRequestFactory) mActivity.mRequestFactory)
+                : getRequestAdapter((CronetUrlRequestContext) mActivity.mUrlRequestContext);
+        NativeTestServer.registerHostResolverProc(urlRequestContextAdapter, api == API.LEGACY);
+        // 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);
+        setUp(SDCH.ENABLED, API.LEGACY);
+        long requestAdapter =
+                getRequestAdapter((ChromiumUrlRequestFactory) mActivity.mRequestFactory);
+        Callback callback = addCallback(requestAdapter, API.LEGACY);
         // Make a request to /sdch/index which advertises the dictionary.
-        TestHttpUrlRequestListener listener1 = startAndWaitForComplete_LegacyAPI(
-                NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
+        TestHttpUrlRequestListener listener1 =
+                startAndWaitForComplete_LegacyAPI(mActivity.mRequestFactory,
+                        NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
         assertEquals(200, listener1.mHttpStatusCode);
         assertEquals("This is an index page.\n", listener1.mResponseAsString);
         assertEquals(Arrays.asList("/sdch/dict/LeQxM80O"),
                 listener1.mResponseHeaders.get("Get-Dictionary"));
 
-        waitForDictionaryAdded("LeQxM80O", true);
+        callback.waitForDictionaryAdded("LeQxM80O");
 
         // Make a request to fetch encoded response at /sdch/test.
-        TestHttpUrlRequestListener listener2 =
-                startAndWaitForComplete_LegacyAPI(NativeTestServer.getSdchURL() + "/sdch/test");
+        TestHttpUrlRequestListener listener2 = startAndWaitForComplete_LegacyAPI(
+                mActivity.mRequestFactory, NativeTestServer.getSdchURL() + "/sdch/test");
         assertEquals(200, listener2.mHttpStatusCode);
         assertEquals("The quick brown fox jumps over the lazy dog.\n", listener2.mResponseAsString);
+        removeCallback(requestAdapter, callback, API.LEGACY);
+
+        String dictUrl = NativeTestServer.getSdchURL() + "/sdch/dict/LeQxM80O";
+        // Poll until pref file contains the latest write.
+        while (true) {
+            Thread.sleep(10000);
+            if (fileContainsString("local_prefs_legacy.json", dictUrl)) {
+                break;
+            }
+            Log.e(TAG, "Waiting for pref file to be updated...");
+        }
+
+        // Test persistence.
+        HttpUrlRequestFactory factory = HttpUrlRequestFactory.createFactory(
+                getInstrumentation().getTargetContext(), mActivity.getContextConfig());
+
+        long newRequestAdapter = getRequestAdapter((ChromiumUrlRequestFactory) factory);
+        NativeTestServer.registerHostResolverProc(newRequestAdapter, true);
+        Callback newCallback = addCallback(newRequestAdapter, API.LEGACY);

[mmenke, 2015/05/20 18:33:41]

This is racy - the dictionary could be loaded before the callback is injected.

One way to fix it would be to check if the SDCH manager has the dictionary we're
looking for before adding an observer via GetDictionaryText, and if so, stop the
wait immediately.

Same goes for the other test.

[xunjieli, 2015/05/20 21:06:12]

Done. You are right! 

+
+        newCallback.waitForDictionaryAdded("LeQxM80O");
+
+        // Make a request to fetch encoded response at /sdch/test.
+        TestHttpUrlRequestListener listener3 = startAndWaitForComplete_LegacyAPI(
+                factory, NativeTestServer.getSdchURL() + "/sdch/test");
+        assertEquals(200, listener3.mHttpStatusCode);
+        assertEquals("The quick brown fox jumps over the lazy dog.\n", listener3.mResponseAsString);
+        removeCallback(newRequestAdapter, newCallback, API.LEGACY);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSdchDisabled_LegacyAPI() throws Exception {
-        setUp(false);
+        setUp(SDCH.DISABLED, API.LEGACY);
         // Make a request to /sdch/index.
         // Since Sdch is not enabled, no dictionary should be advertised.
-        TestHttpUrlRequestListener listener = startAndWaitForComplete_LegacyAPI(
-                NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
+        TestHttpUrlRequestListener listener =
+                startAndWaitForComplete_LegacyAPI(mActivity.mRequestFactory,
+                        NativeTestServer.getSdchURL() + "/sdch/index?q=LeQxM80O");
         assertEquals(200, listener.mHttpStatusCode);
         assertEquals("This is an index page.\n", listener.mResponseAsString);
         assertEquals(null, listener.mResponseHeaders.get("Get-Dictionary"));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testDictionaryNotFound_LegacyAPI() throws Exception {
-        setUp(true);
+        setUp(SDCH.ENABLED, API.LEGACY);
         // Make a request to /sdch/index which advertises a bad dictionary that
         // does not exist.
-        TestHttpUrlRequestListener listener1 = startAndWaitForComplete_LegacyAPI(
-                NativeTestServer.getSdchURL() + "/sdch/index?q=NotFound");
+        TestHttpUrlRequestListener listener1 =
+                startAndWaitForComplete_LegacyAPI(mActivity.mRequestFactory,
+                        NativeTestServer.getSdchURL() + "/sdch/index?q=NotFound");
         assertEquals(200, listener1.mHttpStatusCode);
         assertEquals("This is an index page.\n", listener1.mResponseAsString);
         assertEquals(Arrays.asList("/sdch/dict/NotFound"),
                 listener1.mResponseHeaders.get("Get-Dictionary"));
 
-        waitForDictionaryAdded("NotFound", true);
-
-        // Make a request to fetch /sdch/test, and make sure Sdch encoding is not used.
-        TestHttpUrlRequestListener listener2 =
-                startAndWaitForComplete_LegacyAPI(NativeTestServer.getSdchURL() + "/sdch/test");
+        // Make a request to fetch /sdch/test, and make sure request succeeds.
+        TestHttpUrlRequestListener listener2 = startAndWaitForComplete_LegacyAPI(
+                mActivity.mRequestFactory, 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);
+        setUp(SDCH.ENABLED, API.ASYNC);
+        long requestAdapter =
+                getRequestAdapter((CronetUrlRequestContext) mActivity.mUrlRequestContext);
+        Callback callback = addCallback(requestAdapter, API.ASYNC);
         // 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);
+        callback.waitForDictionaryAdded("LeQxM80O");
 
         // 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);
+        removeCallback(requestAdapter, callback, API.ASYNC);
+
+        // 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(fileContainsString("local_prefs.json", dictUrl));
+
+        // Test persistence.
+        CronetUrlRequestContext newContext = new CronetUrlRequestContext(
+                getInstrumentation().getTargetContext(), mActivity.getContextConfig());
+
+        long newRequestAdapter = getRequestAdapter(newContext);
+        NativeTestServer.registerHostResolverProc(newRequestAdapter, false);
+        Callback newCallback = addCallback(newRequestAdapter, API.ASYNC);
+
+        newCallback.waitForDictionaryAdded("LeQxM80O");
+
+        // 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);
+        removeCallback(newRequestAdapter, newCallback, API.ASYNC);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testSdchDisabled() throws Exception {
-        setUp(false);
+        setUp(SDCH.DISABLED, API.ASYNC);
         // 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);
+        setUp(SDCH.ENABLED, API.ASYNC);
         // 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);
-            if (dict.equals("NotFound")) {
-                assertEquals(404, listener.mResponseInfo.getHttpStatusCode());
-            } else {
-                assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
-                assertTrue(listener.mResponseInfo.wasCached());
-            }
+    private static class Callback extends SdchObserverCallback {
+        ConditionVariable mBlock = new ConditionVariable();
+        private String mLastAddedDict;
+
+        @Override
+        public void onDictionaryAdded(String url) {
+            Log.i(TAG, "Dictionary %s is added ", url);
+            mLastAddedDict = url;
+            mBlock.open();
         }
-        // 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);
+
+        public void waitForDictionaryAdded(String dictName) {
+            mBlock.block();
+            mBlock.close();
+            assertTrue(mLastAddedDict.contains(dictName));
+        }
     }
 
-    private TestHttpUrlRequestListener startAndWaitForComplete_LegacyAPI(String url)
-            throws Exception {
+    // Registers callback.
+    private Callback addCallback(long contextAdapter, API api) {
+        Callback callback = new Callback();
+        SdchTestUtil.registerSdchObserverCallback(contextAdapter, callback, api == API.LEGACY);
+        return callback;
+    }
+
+    // Unregisters callback.
+    private void removeCallback(long contextAdapter, Callback callback, API api) {
+        SdchTestUtil.unregisterSdchObserverCallback(contextAdapter, callback, api == API.LEGACY);
+    }
+
+    private long getRequestAdapter(ChromiumUrlRequestFactory factory) {
+        return factory.getRequestContext().getUrlRequestContextAdapter();
+    }
+
+    private long getRequestAdapter(CronetUrlRequestContext requestContext) {
+        return requestContext.getUrlRequestContextAdapter();
+    }
+
+    private TestHttpUrlRequestListener startAndWaitForComplete_LegacyAPI(
+            HttpUrlRequestFactory factory, String url) throws Exception {
         Map<String, String> headers = new HashMap<String, String>();
         TestHttpUrlRequestListener listener = new TestHttpUrlRequestListener();
-        HttpUrlRequest request = mActivity.mRequestFactory.createRequest(
+        HttpUrlRequest request = factory.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 file contains a particular string.
+    private boolean fileContainsString(String filename, String content) throws IOException {
+        BufferedReader reader =
+                new BufferedReader(new FileReader(mActivity.getTestStorage() + "/" + filename));
+        String line;
+        while ((line = reader.readLine()) != null) {
+            if (line.contains(content)) {
+                reader.close();
+                return true;
+            }
+        }
+        reader.close();
+        return false;
+    }
 }