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 37 matching lines @@
         urlRequest.start();
         listener.blockForDone();
         assertTrue(urlRequest.isDone());
         return listener;
     }
 
     private void checkResponseInfo(ResponseInfo 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);
     }
 
     private void checkResponseInfoHeader(ResponseInfo responseInfo,
             String headerName, String headerValue) {
         Map<String, List<String>> responseHeaders =
                 responseInfo.getAllHeaders();
         List<String> header = responseHeaders.get(headerName);
         assertNotNull(header);
         assertTrue(header.contains(headerValue));
     }
@@ skipping 28 matching lines @@
         UrlRequest urlRequest = mActivity.mUrlRequestContext.createRequest(
                 NativeTestServer.getRedirectURL(), listener, listener.getExecutor());
         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 233 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;
         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]);
+        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);
+        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 1038 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);
     }
 }