Test alternate Job failing but request succeeding.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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.
 
 #include "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 9310 matching lines @@
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
+// A request to a server with an alternative service fires two Jobs: one to the
+// origin, and an alternate one to the alternative server.  If the former
+// succeeds but the latter fails, the request should succeed.
+TEST_P(HttpNetworkTransactionTest, FailedAlternativeServiceIsNotUserVisible) {
+  HostPortPair origin("origin.example.org", 443);
+  HostPortPair alternative("alternative.example.org", 443);
+
+  // Connection to alternative server fails.
+  StaticSocketDataProvider refused_data;
+  refused_data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));

[Ryan Hamilton, 2015/05/08 21:20:26]

I was thinking that this would be testing the "don't use http/1" path. Does this
test still pass if you remove the connect data, and use
ssl.SetNextProto(kProtoHTTP11) instead? (Because we should not use the socket
for alt-svc)

[Bence, 2015/05/11 16:11:29]

Oh okay.  Sorry it wasn't clear to me from https://crrev.com/1121043002/#msg13.

Done.

+  session_deps_.socket_factory->AddSocketDataProvider(&refused_data);
+
+  // Connection to origin server succeeds.
+  SSLSocketDataProvider ssl(ASYNC, OK);
+  ssl.SetNextProto(kProtoHTTP11);
+  session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
+
+  MockWrite http_writes[] = {
+      MockWrite(
+          "GET / HTTP/1.1\r\n"
+          "Host: origin.example.org\r\n"
+          "Connection: keep-alive\r\n\r\n"),
+  };
+
+  MockRead http_reads[] = {
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead("Content-Type: text/html\r\n"),
+      MockRead("Content-Length: 6\r\n\r\n"),
+      MockRead("foobar"),
+  };
+  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
+                                     http_writes, arraysize(http_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&http_data);
+
+  // Set up alternative service for origin.
+  session_deps_.use_alternate_protocols = true;
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+  base::WeakPtr<HttpServerProperties> http_server_properties =
+      session->http_server_properties();
+  AlternativeService alternative_service(
+      AlternateProtocolFromNextProto(GetParam()), alternative);
+  http_server_properties->SetAlternativeService(origin, alternative_service,
+                                                1.0);
+
+  HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("https://origin.example.org:443");
+  request.load_flags = 0;
+  TestCompletionCallback callback;
+
+  int rv = trans.Start(&request, callback.callback(), BoundNetLog());
+  rv = callback.GetResult(rv);
+  EXPECT_EQ(OK, rv);
+
+  const HttpResponseInfo* response = trans.GetResponseInfo();
+  ASSERT_TRUE(response != nullptr);
+  ASSERT_TRUE(response->headers.get() != nullptr);
+  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+
+  std::string response_data;
+  ASSERT_EQ(OK, ReadTransaction(&trans, &response_data));
+  EXPECT_EQ("foobar", response_data);
+
+  // Failure to alternative server should be recorded in HttpServerProperties.
+  EXPECT_TRUE(
+      http_server_properties->IsAlternativeServiceBroken(alternative_service));
+}

[Ryan Hamilton, 2015/05/08 21:20:26]

Looks great. Can you add a second transaction and confirm that it goes over the
existing http/1.1 socket and does not fire up a new alt-svc job (and hence no
new socket).

[Bence, 2015/05/11 16:11:29]

Done.

+
 TEST_P(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
   session_deps_.use_alternate_protocols = true;
   session_deps_.next_protos = SpdyNextProtos();
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   request.load_flags = 0;
 
   std::string alternate_protocol_http_header =
@@ skipping 4665 matching lines @@
   ASSERT_TRUE(response);
   ASSERT_TRUE(response->headers.get());
 
   EXPECT_EQ(101, response->headers->response_code());
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 }  // namespace net