[DevTools] Always report encodedDataLength in Network.ResponseReceived.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 2087 matching lines @@
       base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback,
                  base::Unretained(&helper)));
   ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   data.Resume();
 
   // Finish running rest of tasks.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
+TEST_F(SpdyNetworkTransactionTest, TestRawHeaderSizeSuccessfullRequest) {
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
+  headers["user-agent"] = "";
+  headers["accept-encoding"] = "gzip, deflate";
+
+  SpdySerializedFrame req(
+      spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0),
+  };
+
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+
+  SpdySerializedFrame response_body_frame(
+      spdy_util_.ConstructSpdyDataFrame(1, "should not include", 18, true));
+
+  MockRead response_headers(CreateMockRead(resp, 1));
+  MockRead reads[] = {
+      response_headers, CreateMockRead(response_body_frame, 2),
+      MockRead(ASYNC, 0, 0, 3)  // EOF
+  };
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
+  TestDelegate delegate;
+  SpdyURLRequestContext spdy_url_request_context;
+  TestNetworkDelegate network_delegate;
+  spdy_url_request_context.set_network_delegate(&network_delegate);
+  SSLSocketDataProvider ssl_data(ASYNC, OK);
+  ssl_data.next_proto = kProtoHTTP2;
+
+  std::unique_ptr<URLRequest> request(spdy_url_request_context.CreateRequest(
+      GURL(kDefaultUrl), DEFAULT_PRIORITY, &delegate));
+  spdy_url_request_context.socket_factory().AddSSLSocketDataProvider(&ssl_data);
+  spdy_url_request_context.socket_factory().AddSocketDataProvider(&data);
+
+  request->Start();
+  base::RunLoop().Run();
+
+  EXPECT_LT(0, request->GetTotalSentBytes());
+  EXPECT_LT(0, request->GetTotalReceivedBytes());
+  EXPECT_EQ(network_delegate.total_network_bytes_sent(),
+            request->GetTotalSentBytes());
+  EXPECT_EQ(network_delegate.total_network_bytes_received(),
+            request->GetTotalReceivedBytes());
+  EXPECT_EQ(response_headers.data_len, request->raw_header_size());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+}
+
+TEST_F(SpdyNetworkTransactionTest,
+       TestRawHeaderSizeSuccessfullPushHeadersFirst) {
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
+  headers["user-agent"] = "";
+  headers["accept-encoding"] = "gzip, deflate";
+
+  SpdySerializedFrame req(
+      spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
+  MockWrite writes[] = {
+      CreateMockWrite(req, 0),
+  };
+
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+  SpdySerializedFrame response_body_frame(
+      spdy_util_.ConstructSpdyDataFrame(1, "should not include", 18, true));
+
+  SpdyHeaderBlock push_headers;
+  spdy_util_.AddUrlToHeaderBlock(std::string(kDefaultUrl) + "b.dat",
+                                 &push_headers);
+
+  SpdySerializedFrame push_init_frame(
+      spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 2, 1));
+
+  SpdySerializedFrame push_headers_frame(
+      spdy_util_.ConstructSpdyPushHeaders(2, nullptr, 0));
+
+  SpdySerializedFrame push_body_frame(spdy_util_.ConstructSpdyDataFrame(
+      2, "should not include either", 25, false));
+
+  MockRead push_init_read(CreateMockRead(push_init_frame, 1));
+  MockRead response_headers(CreateMockRead(resp, 4));
+  // raw_header_size() will contain the size of the push promise frame
+  // initialization.
+  int expected_response_headers_size =
+      response_headers.data_len + push_init_read.data_len;
+
+  MockRead reads[] = {
+      push_init_read,
+      CreateMockRead(push_headers_frame, 2),
+      CreateMockRead(push_body_frame, 3),
+      response_headers,
+      CreateMockRead(response_body_frame, 5),
+      MockRead(ASYNC, 0, 6)  // EOF
+  };
+
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
+  TestDelegate delegate;
+  SpdyURLRequestContext spdy_url_request_context;
+  TestNetworkDelegate network_delegate;
+  spdy_url_request_context.set_network_delegate(&network_delegate);
+  SSLSocketDataProvider ssl_data(ASYNC, OK);
+  ssl_data.next_proto = kProtoHTTP2;
+
+  std::unique_ptr<URLRequest> request(spdy_url_request_context.CreateRequest(
+      GURL(kDefaultUrl), DEFAULT_PRIORITY, &delegate));
+  spdy_url_request_context.socket_factory().AddSSLSocketDataProvider(&ssl_data);
+  spdy_url_request_context.socket_factory().AddSocketDataProvider(&data);
+
+  request->Start();
+  base::RunLoop().Run();
+
+  EXPECT_LT(0, request->GetTotalSentBytes());
+  EXPECT_LT(0, request->GetTotalReceivedBytes());
+  EXPECT_EQ(network_delegate.total_network_bytes_sent(),
+            request->GetTotalSentBytes());
+  EXPECT_EQ(network_delegate.total_network_bytes_received(),
+            request->GetTotalReceivedBytes());
+  EXPECT_EQ(expected_response_headers_size, request->raw_header_size());
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+}
+
 // Send a spdy request to www.example.org that gets redirected to www.foo.com.
 TEST_F(SpdyNetworkTransactionTest, DISABLED_RedirectGetRequest) {
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
 
   // Setup writes/reads to www.example.org
   SpdySerializedFrame req(
       spdy_util_.ConstructSpdyHeaders(1, std::move(headers), LOWEST, true));
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReplyRedirect(1));
@@ skipping 40 matching lines @@
     d.set_quit_on_redirect(true);
     r->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.received_redirect_count());
 
     r->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
+    EXPECT_EQ(OK, r->status().error());
     std::string contents("hello!");
     EXPECT_EQ(contents, d.data_received());
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 // Send a spdy request to www.example.org. Get a pushed stream that redirects to
@@ skipping 65 matching lines @@
 
     d2.set_quit_on_redirect(true);
     r2->Start();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.received_redirect_count());
 
     r2->FollowDeferredRedirect();
     base::RunLoop().Run();
     EXPECT_EQ(1, d2.response_started_count());
     EXPECT_FALSE(d2.received_data_before_response());
-    EXPECT_EQ(URLRequestStatus::SUCCESS, r2->status().status());
+    EXPECT_EQ(OK, r2->status().error());
     std::string contents2("hello!");
     EXPECT_EQ(contents2, d2.data_received());
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 TEST_F(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
@@ skipping 3961 matching lines @@
 TEST_F(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net