[DevTools] Always report encodedDataLength in Network.ResponseReceived.

net/url_request/url_request.h

Index: net/url_request/url_request.h
diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h
index 005ae29d2cbc2627e869c4f65e99ba52393d5941..860d7e9c00c3f8732d8ba73b04502e986ff00506 100644
--- a/net/url_request/url_request.h
+++ b/net/url_request/url_request.h
@@ -648,6 +648,9 @@ class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
   // 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; }
@@ -848,6 +851,9 @@ class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
   // 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);
 };