[DevTools] Always report encodedDataLength in Network.ResponseReceived.

net/url_request/url_request.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 630 matching lines @@
   // the more general response_info() is available, even though it is a subset.
   const HostPortPair& proxy_server() const {
     return proxy_server_;
   }
 
   // Gets the connection attempts made in the process of servicing this
   // URLRequest. Only guaranteed to be valid if called after the request fails
   // or after the response headers are received.
   void GetConnectionAttempts(ConnectionAttempts* out) const;
 
+  // Gets the raw header size of the request.

[mmenke, 2016/07/21 18:10:50]

It's unclear what "raw header size" means.  You should document this and rename
it (over_the_wire_response_header_size()?)

This is over-the-wire response (Not request) header size (0 if response was
cached, or unable to parse headers).  Some random value for HTTP/0.9 (Good thing
we're removing support).  It may or may not include protocol overhead (For H2 it
does, for QUIC it does not, it does not include HTTPS overhead).  It also may
include a random number of bytes that we read after the end of an HTTP/1.x
header, which may in fact exceed the size of the entire HTTP response.

Hrm...This is starting to sound pretty iffy, as a web-exposed API...

[mmenke, 2016/07/21 18:47:02]

Actually, I think with H2/QUIC, it may be able to include part of the body as
well, at least with pushed streams.  Not sure about other streams.

[allada, 2016/07/22 17:19:32]

This property contains the value of the size in bytes of the header not
including SSL overhead but does include H2/Quic/HTTP overhead. I am ok changing
it, but I don't know a much better name since it's not actually "over the wire
size".
From what I can see in H2 we are using the value that comes from SpdyStream
which represents a resource. Unless content can be sent and put into this class
before headers are processed it should be safe. With Quic it appears to do the
same (QuicSpdyStream). I ran some tests on a simple Go H2 server I wrote and it
appears to work as expected (tested multiple concurrent resources over same
socket), but have not tested on complex H2 requests.

[mmenke, 2016/07/22 18:50:09]

Hrm...Digging into HttpStreamParser, it looks like this may actually work, since
it doesn't actually return bytes read there.

That having been said, I can't sign off on this without unit tests that this
actually returns header size, and not over-the-wire bytes that we've read from
the socket (For HTTP, in particular, we don't know header size, so we
potentially have to read a lot more data before we learn the size of the
headers), and updated API descriptions supporting this use case.

This is something that seems like it could invisibly break, causing real
regressions, but not failures, and no developers would notice it.  If it's worth
doing, it's worth trying to ensure it doesn't break.

Could even make an explicit API to get header size, down to the HttpStream
layer, to even further reduce risk of regression.

+  int raw_header_size() const { return raw_header_size_; }
+
  protected:
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
   void set_status(const URLRequestStatus& value) { status_ = value; }
 
   // Allow the URLRequestJob to redirect this request.  Returns OK if
   // successful, otherwise an error code is returned.
   int Redirect(const RedirectInfo& redirect_info);
@@ skipping 180 matching lines @@
 
   base::TimeTicks creation_time_;
 
   // Timing information for the most recent request.  Its start times are
   // populated during Start(), and the rest are populated in OnResponseReceived.
   LoadTimingInfo load_timing_info_;
 
   // The proxy server used for this request, if any.
   HostPortPair proxy_server_;
 
+  // The raw header size of the request.
+  int raw_header_size_;
+
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_