Modify instrumentation for various jank bugs, mostly removing outdated sites.

net/http/http_stream_parser.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 "net/http/http_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 345 matching lines @@
 
   return result;
 }
 
 void HttpStreamParser::OnIOComplete(int result) {
   result = DoLoop(result);
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
   if (result != ERR_IO_PENDING && !callback_.is_null()) {
-    // TODO(vadimt): Remove ScopedTracker below once crbug.com/424359 is fixed.
-    tracked_objects::ScopedTracker tracking_profile(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "424359 HttpStreamParser::OnIOComplete callback"));
-
     CompletionCallback c = callback_;
     callback_.Reset();
     c.Run(result);
   }
 }
 
 int HttpStreamParser::DoLoop(int result) {
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("424359 HttpStreamParser::DoLoop"));
 
   do {
     DCHECK_NE(ERR_IO_PENDING, result);
     DCHECK_NE(STATE_DONE, io_state_);
     DCHECK_NE(STATE_NONE, io_state_);
     State state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
@@ skipping 35 matching lines @@
         NOTREACHED();
         break;
     }
   } while (result != ERR_IO_PENDING &&
            (io_state_ != STATE_DONE && io_state_ != STATE_NONE));
 
   return result;
 }
 
 int HttpStreamParser::DoSendHeaders() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoSendHeaders"));
+
   int bytes_remaining = request_headers_->BytesRemaining();
   DCHECK_GT(bytes_remaining, 0);
 
   // Record our best estimate of the 'request time' as the time when we send
   // out the first bytes of the request headers.
   if (bytes_remaining == request_headers_->size())
     response_->request_time = base::Time::Now();
 
   io_state_ = STATE_SEND_HEADERS_COMPLETE;
   return connection_->socket()
       ->Write(request_headers_.get(), bytes_remaining, io_callback_);
 }
 
 int HttpStreamParser::DoSendHeadersComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoSendHeadersComplete"));
+
   if (result < 0) {
     // In the unlikely case that the headers and body were merged, all the
     // the headers were sent, but not all of the body way, and |result| is
     // an error that this should try reading after, stash the error for now and
     // act like the request was successfully sent.
     if (request_headers_->BytesConsumed() >= request_headers_length_ &&
         ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
@@ skipping 19 matching lines @@
                    false /* not merged */));
     io_state_ = STATE_SEND_BODY;
     return OK;
   }
 
   // Finished sending the request.
   return OK;
 }
 
 int HttpStreamParser::DoSendBody() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("424359 HttpStreamParser::DoSendBody"));
+
   if (request_body_send_buf_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_BODY_COMPLETE;
     return connection_->socket()
         ->Write(request_body_send_buf_.get(),
                 request_body_send_buf_->BytesRemaining(),
                 io_callback_);
   }
 
   if (request_->upload_data_stream->is_chunked() && sent_last_chunk_) {
     // Finished sending the request.
     return OK;
   }
 
   request_body_read_buf_->Clear();
   io_state_ = STATE_SEND_REQUEST_READ_BODY_COMPLETE;
   return request_->upload_data_stream->Read(request_body_read_buf_.get(),
                                             request_body_read_buf_->capacity(),
                                             io_callback_);
 }
 
 int HttpStreamParser::DoSendBodyComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoSendBodyComplete"));
+
   if (result < 0) {
     // If |result| is an error that this should try reading after, stash the
     // error for now and act like the request was successfully sent.
     if (ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
   request_body_send_buf_->DidConsume(result);
 
   io_state_ = STATE_SEND_BODY;
   return OK;
 }
 
 int HttpStreamParser::DoSendRequestReadBodyComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoSendRequestReadBodyComplete"));
+
   // |result| is the result of read from the request body from the last call to
   // DoSendBody().
   DCHECK_GE(result, 0);  // There won't be errors.
 
   // Chunked data needs to be encoded.
   if (request_->upload_data_stream->is_chunked()) {
     if (result == 0) {  // Reached the end.
       DCHECK(request_->upload_data_stream->IsEOF());
       sent_last_chunk_ = true;
     }
@@ skipping 13 matching lines @@
     // Finished sending the request.
   } else if (result > 0) {
     request_body_send_buf_->DidAppend(result);
     result = 0;
     io_state_ = STATE_SEND_BODY;
   }
   return result;
 }
 
 int HttpStreamParser::DoReadHeaders() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoReadHeaders"));
+
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (read_buf_->RemainingCapacity() == 0)
     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
 
   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
 
   return connection_->socket()
       ->Read(read_buf_.get(), read_buf_->RemainingCapacity(), io_callback_);
 }
 
 int HttpStreamParser::DoReadHeadersComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoReadHeadersComplete"));
+
   result = HandleReadHeaderResult(result);
 
   // TODO(mmenke):  The code below is ugly and hacky.  A much better and more
   // flexible long term solution would be to separate out the read and write
   // loops, though this would involve significant changes, both here and
   // elsewhere (WebSockets, for instance).
 
   // If still reading the headers, or there was no error uploading the request
   // body, just return the result.
   if (io_state_ == STATE_READ_HEADERS || upload_error_ == OK)
@@ skipping 27 matching lines @@
   // make sure the consumer has some indication there was an error.
 
   // Nothing else to do.
   io_state_ = STATE_DONE;
   // Don't let caller see the headers.
   response_->headers = NULL;
   return upload_error_;
 }
 
 int HttpStreamParser::DoReadBody() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("424359 HttpStreamParser::DoReadBody"));
+
   io_state_ = STATE_READ_BODY_COMPLETE;
 
   // There may be some data left over from reading the response headers.
   if (read_buf_->offset()) {
     int available = read_buf_->offset() - read_buf_unused_offset_;
     if (available) {
       CHECK_GT(available, 0);
       int bytes_from_buffer = std::min(available, user_read_buf_len_);
       memcpy(user_read_buf_->data(),
              read_buf_->StartOfBuffer() + read_buf_unused_offset_,
@@ skipping 13 matching lines @@
   // Check to see if we're done reading.
   if (IsResponseBodyComplete())
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
   return connection_->socket()
       ->Read(user_read_buf_.get(), user_read_buf_len_, io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/424359 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "424359 HttpStreamParser::DoReadBodyComplete"));
+
   // When the connection is closed, there are numerous ways to interpret it.
   //
   //  - If a Content-Length header is present and the body contains exactly that
   //    number of bytes at connection close, the response is successful.
   //
   //  - If a Content-Length header is present and the body contains fewer bytes
   //    than promised by the header at connection close, it may indicate that
   //    the connection was closed prematurely, or it may indicate that the
   //    server sent an invalid Content-Length header. Unfortunately, the invalid
   //    Content-Length header case does occur in practice and other browsers are
@@ skipping 392 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     uint64 merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net