Update ResponseInfo to UrlResponseInfo with API review comments.

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

 // Copyright 2014 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 android.util.Pair;
 
 import org.chromium.base.test.util.Feature;
 import org.chromium.net.TestUrlRequestListener.FailureType;
 import org.chromium.net.TestUrlRequestListener.ResponseStep;
 import org.chromium.net.test.FailurePhase;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ skipping 34 matching lines @@
         // Create request.
         UrlRequest.Builder builder = new UrlRequest.Builder(
                 url, listener, listener.getExecutor(), mActivity.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         listener.blockForDone();
         assertTrue(urlRequest.isDone());
         return listener;
     }
 
-    private void checkResponseInfo(ResponseInfo responseInfo,
-            String expectedUrl, int expectedHttpStatusCode,
-            String expectedHttpStatusText) {
+    private void checkResponseInfo(UrlResponseInfo responseInfo, String expectedUrl,
+            int expectedHttpStatusCode, String expectedHttpStatusText) {
         assertEquals(expectedUrl, responseInfo.getUrl());
-        assertEquals(expectedUrl, responseInfo.getUrlChain()[
-                responseInfo.getUrlChain().length - 1]);
+        assertEquals(
+                expectedUrl, responseInfo.getUrlChain().get(responseInfo.getUrlChain().size() - 1));
         assertEquals(expectedHttpStatusCode, responseInfo.getHttpStatusCode());
         assertEquals(expectedHttpStatusText, responseInfo.getHttpStatusText());
         assertFalse(responseInfo.wasCached());
+        assertTrue(responseInfo.toString().length() > 0);

[xunjieli, 2015/10/05 20:39:02]

Instead of doing this, maybe add a check for testSimpleGet to assert on the full
string format of the responseInfo.

[mef, 2015/10/05 22:09:19]

Done.

     }
 
-    private void checkResponseInfoHeader(ResponseInfo responseInfo,
-            String headerName, String headerValue) {
+    private void checkResponseInfoHeader(
+            UrlResponseInfo responseInfo, String headerName, String headerValue) {
         Map<String, List<String>> responseHeaders =
                 responseInfo.getAllHeaders();
         List<String> header = responseHeaders.get(headerName);
         assertNotNull(header);
         assertTrue(header.contains(headerValue));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testBuilderChecks() throws Exception {
@@ skipping 35 matching lines @@
     public void testSimpleGet() throws Exception {
         TestUrlRequestListener listener = startAndWaitForComplete(
                 NativeTestServer.getEchoMethodURL());
         assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
         // Default method is 'GET'.
         assertEquals("GET", listener.mResponseAsString);
         assertEquals(0, listener.mRedirectCount);
         assertEquals(listener.mResponseStep, ResponseStep.ON_SUCCEEDED);
         checkResponseInfo(listener.mResponseInfo,
                 NativeTestServer.getEchoMethodURL(), 200, "OK");
-        checkResponseInfo(listener.mExtendedResponseInfo.getResponseInfo(),
-                NativeTestServer.getEchoMethodURL(), 200, "OK");
     }
 
     /**
      * Tests a redirect by running it step-by-step. Also tests that delaying a
      * request works as expected. To make sure there are no unexpected pending
      * messages, does a GET between UrlRequestListener callbacks.
      */
     @SmallTest
     @Feature({"Cronet"})
     public void testRedirectAsync() throws Exception {
         // Start the request and wait to see the redirect.
         TestUrlRequestListener listener = new TestUrlRequestListener();
         listener.setAutoAdvance(false);
         UrlRequest.Builder builder = new UrlRequest.Builder(NativeTestServer.getRedirectURL(),
                 listener, listener.getExecutor(), mActivity.mCronetEngine);
         UrlRequest urlRequest = builder.build();
         urlRequest.start();
         listener.waitForNextStep();
 
         // Check the redirect.
         assertEquals(ResponseStep.ON_RECEIVED_REDIRECT, listener.mResponseStep);
         assertEquals(1, listener.mRedirectResponseInfoList.size());
         checkResponseInfo(listener.mRedirectResponseInfoList.get(0),
                 NativeTestServer.getRedirectURL(), 302, "Found");
-        assertEquals(1,
-                listener.mRedirectResponseInfoList.get(0).getUrlChain().length);
+        assertEquals(1, listener.mRedirectResponseInfoList.get(0).getUrlChain().size());
         assertEquals(NativeTestServer.getSuccessURL(), listener.mRedirectUrlList.get(0));
         checkResponseInfoHeader(listener.mRedirectResponseInfoList.get(0),
                 "redirect-header", "header-value");
 
         // Wait for an unrelated request to finish. The request should not
         // advance until followRedirect is invoked.
         testSimpleGet();
         assertEquals(ResponseStep.ON_RECEIVED_REDIRECT, listener.mResponseStep);
         assertEquals(1, listener.mRedirectResponseInfoList.size());
 
         // Follow the redirect and wait for the next set of headers.
         urlRequest.followRedirect();
         listener.waitForNextStep();
 
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, listener.mResponseStep);
         assertEquals(1, listener.mRedirectResponseInfoList.size());
         assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
         checkResponseInfo(listener.mResponseInfo, NativeTestServer.getSuccessURL(), 200, "OK");
-        assertEquals(2, listener.mResponseInfo.getUrlChain().length);
-        assertEquals(NativeTestServer.getRedirectURL(), listener.mResponseInfo.getUrlChain()[0]);
-        assertEquals(NativeTestServer.getSuccessURL(), listener.mResponseInfo.getUrlChain()[1]);
+        assertEquals(2, listener.mResponseInfo.getUrlChain().size());
+        assertEquals(
+                NativeTestServer.getRedirectURL(), listener.mResponseInfo.getUrlChain().get(0));
+        assertEquals(NativeTestServer.getSuccessURL(), listener.mResponseInfo.getUrlChain().get(1));
 
         // Wait for an unrelated request to finish. The request should not
         // advance until read is invoked.
         testSimpleGet();
         assertEquals(ResponseStep.ON_RESPONSE_STARTED, listener.mResponseStep);
 
         // One read should get all the characters, but best not to depend on
         // how much is actually read from the socket at once.
         while (!listener.isDone()) {
             listener.startNextRead(urlRequest);
@@ skipping 16 matching lines @@
         // asserts in TestURLRequestListener.
         testSimpleGet();
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testNotFound() throws Exception {
         String url = NativeTestServer.getFileURL("/notfound.html");
         TestUrlRequestListener listener = startAndWaitForComplete(url);
         checkResponseInfo(listener.mResponseInfo, url, 404, "Not Found");
-        checkResponseInfo(listener.mExtendedResponseInfo.getResponseInfo(),
-                url, 404, "Not Found");
         assertEquals(
                 "<!DOCTYPE html>\n<html>\n<head>\n<title>Not found</title>\n"
                 + "<p>Test page loaded.</p>\n</head>\n</html>\n",
                 listener.mResponseAsString);
         assertEquals(0, listener.mRedirectCount);
         assertEquals(listener.mResponseStep, ResponseStep.ON_SUCCEEDED);
     }
 
     // Checks that UrlRequestListener.onFailed is only called once in the case
     // of ERR_CONTENT_LENGTH_MISMATCH, which has an unusual failure path.
@@ skipping 181 matching lines @@
         assertEquals(2, multiHeader.size());
         assertEquals("header-value1", multiHeader.get(0));
         assertEquals("header-value2", multiHeader.get(1));
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testResponseHeadersList() throws Exception {
         TestUrlRequestListener listener = startAndWaitForComplete(NativeTestServer.getSuccessURL());
         assertEquals(200, listener.mResponseInfo.getHttpStatusCode());
-        List<Pair<String, String>> responseHeaders =
+        List<Map.Entry<String, String>> responseHeaders =
                 listener.mResponseInfo.getAllHeadersAsList();
         assertEquals(5, responseHeaders.size());
-        assertEquals("Content-Type", responseHeaders.get(0).first);
-        assertEquals("text/plain", responseHeaders.get(0).second);
-        assertEquals("Access-Control-Allow-Origin",
-                responseHeaders.get(1).first);
-        assertEquals("*", responseHeaders.get(1).second);
-        assertEquals("header-name", responseHeaders.get(2).first);
-        assertEquals("header-value", responseHeaders.get(2).second);
-        assertEquals("multi-header-name", responseHeaders.get(3).first);
-        assertEquals("header-value1", responseHeaders.get(3).second);
-        assertEquals("multi-header-name", responseHeaders.get(4).first);
-        assertEquals("header-value2", responseHeaders.get(4).second);
+        assertEquals("Content-Type", responseHeaders.get(0).getKey());
+        assertEquals("text/plain", responseHeaders.get(0).getValue());
+        assertEquals("Access-Control-Allow-Origin", responseHeaders.get(1).getKey());
+        assertEquals("*", responseHeaders.get(1).getValue());
+        assertEquals("header-name", responseHeaders.get(2).getKey());
+        assertEquals("header-value", responseHeaders.get(2).getValue());
+        assertEquals("multi-header-name", responseHeaders.get(3).getKey());
+        assertEquals("header-value1", responseHeaders.get(3).getValue());
+        assertEquals("multi-header-name", responseHeaders.get(4).getKey());
+        assertEquals("header-value2", responseHeaders.get(4).getValue());
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMockMultiRedirect() throws Exception {
         TestUrlRequestListener listener =
                 startAndWaitForComplete(NativeTestServer.getMultiRedirectURL());
-        ResponseInfo mResponseInfo = listener.mResponseInfo;
+        UrlResponseInfo mResponseInfo = listener.mResponseInfo;
         assertEquals(2, listener.mRedirectCount);
         assertEquals(200, mResponseInfo.getHttpStatusCode());
         assertEquals(2, listener.mRedirectResponseInfoList.size());
 
         // Check first redirect (multiredirect.html -> redirect.html)
-        ResponseInfo firstRedirectResponseInfo =
-                listener.mRedirectResponseInfoList.get(0);
-        assertEquals(1, firstRedirectResponseInfo.getUrlChain().length);
-        assertEquals(
-                NativeTestServer.getMultiRedirectURL(), firstRedirectResponseInfo.getUrlChain()[0]);
+        UrlResponseInfo firstRedirectResponseInfo = listener.mRedirectResponseInfoList.get(0);
+        assertEquals(1, firstRedirectResponseInfo.getUrlChain().size());
+        assertEquals(NativeTestServer.getMultiRedirectURL(),
+                firstRedirectResponseInfo.getUrlChain().get(0));
         checkResponseInfo(
                 firstRedirectResponseInfo, NativeTestServer.getMultiRedirectURL(), 302, "Found");
         checkResponseInfoHeader(firstRedirectResponseInfo,
                 "redirect-header0", "header-value");
 
         // Check second redirect (redirect.html -> success.txt)
-        ResponseInfo secondRedirectResponseInfo =
-                listener.mRedirectResponseInfoList.get(1);
-        assertEquals(2, secondRedirectResponseInfo.getUrlChain().length);
+        UrlResponseInfo secondRedirectResponseInfo = listener.mRedirectResponseInfoList.get(1);
+        assertEquals(2, secondRedirectResponseInfo.getUrlChain().size());
         assertEquals(NativeTestServer.getMultiRedirectURL(),
-                secondRedirectResponseInfo.getUrlChain()[0]);
+                secondRedirectResponseInfo.getUrlChain().get(0));
         assertEquals(
-                NativeTestServer.getRedirectURL(), secondRedirectResponseInfo.getUrlChain()[1]);
+                NativeTestServer.getRedirectURL(), secondRedirectResponseInfo.getUrlChain().get(1));
         checkResponseInfo(
                 secondRedirectResponseInfo, NativeTestServer.getRedirectURL(), 302, "Found");
         checkResponseInfoHeader(secondRedirectResponseInfo,
                 "redirect-header", "header-value");
 
         // Check final response (success.txt).
         assertEquals(NativeTestServer.getSuccessURL(), mResponseInfo.getUrl());
-        assertEquals(3, mResponseInfo.getUrlChain().length);
-        assertEquals(NativeTestServer.getMultiRedirectURL(), mResponseInfo.getUrlChain()[0]);
-        assertEquals(NativeTestServer.getRedirectURL(), mResponseInfo.getUrlChain()[1]);
-        assertEquals(NativeTestServer.getSuccessURL(), mResponseInfo.getUrlChain()[2]);
+        assertEquals(3, mResponseInfo.getUrlChain().size());
+        assertEquals(NativeTestServer.getMultiRedirectURL(), mResponseInfo.getUrlChain().get(0));
+        assertEquals(NativeTestServer.getRedirectURL(), mResponseInfo.getUrlChain().get(1));
+        assertEquals(NativeTestServer.getSuccessURL(), mResponseInfo.getUrlChain().get(2));
         assertTrue(listener.mHttpResponseDataLength != 0);
         assertEquals(2, listener.mRedirectCount);
         assertEquals(listener.mResponseStep, ResponseStep.ON_SUCCEEDED);
     }
 
     @SmallTest
     @Feature({"Cronet"})
     public void testMockNotFound() throws Exception {
         TestUrlRequestListener listener =
                 startAndWaitForComplete(NativeTestServer.getNotFoundURL());
@@ skipping 1051 matching lines @@
             int end) {
         // Use a duplicate to avoid modifying byteBuffer.
         ByteBuffer duplicate = byteBuffer.duplicate();
         duplicate.position(start);
         duplicate.limit(end);
         byte[] contents = new byte[duplicate.remaining()];
         duplicate.get(contents);
         return new String(contents);
     }
 }