Update from https://crrev.com/316786

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
-#include "base/metrics/stats_counters.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
@@ skipping 682 matching lines @@
   DCHECK_EQ(read_state_, READ_STATE_DO_READ);
   DCHECK_EQ(write_state_, WRITE_STATE_IDLE);
   DCHECK(!connection_);
 
   DCHECK(certificate_error_code == OK ||
          certificate_error_code < ERR_IO_PENDING);
   // TODO(akalin): Check connection->is_initialized() instead. This
   // requires re-working CreateFakeSpdySession(), though.
   DCHECK(connection->socket());
 
-  base::StatsCounter spdy_sessions("spdy.sessions");
-  spdy_sessions.Increment();
-
   connection_ = connection.Pass();
   is_secure_ = is_secure;
   certificate_error_code_ = certificate_error_code;
 
   NextProto protocol_negotiated =
       connection_->socket()->GetNegotiatedProtocol();
   if (protocol_negotiated != kProtoUnknown) {
     protocol_ = protocol_negotiated;
     stream_initial_send_window_size_ = GetInitialWindowSize(protocol_);
   }
@@ skipping 343 matching lines @@
     syn_frame.reset(buffered_spdy_framer_->SerializeFrame(syn_stream));
   } else {
     SpdyHeadersIR headers(stream_id);
     headers.set_priority(spdy_priority);
     headers.set_has_priority(true);
     headers.set_fin((flags & CONTROL_FLAG_FIN) != 0);
     headers.set_name_value_block(block);
     syn_frame.reset(buffered_spdy_framer_->SerializeFrame(headers));
   }
 
-  base::StatsCounter spdy_requests("spdy.requests");
-  spdy_requests.Increment();
   streams_initiated_count_++;
 
   if (net_log().IsLogging()) {
     net_log().AddEvent(NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
                        base::Bind(&NetLogSpdySynStreamSentCallback,
                                   &block,
                                   (flags & CONTROL_FLAG_FIN) != 0,
                                   (flags & CONTROL_FLAG_UNIDIRECTIONAL) != 0,
                                   spdy_priority,
                                   stream_id));
@@ skipping 362 matching lines @@
     }
 
     DCHECK_EQ(buffered_spdy_framer_->error_code(), SpdyFramer::SPDY_NO_ERROR);
   }
 
   read_state_ = READ_STATE_DO_READ;
   return OK;
 }
 
 void SpdySession::PumpWriteLoop(WriteState expected_write_state, int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457517 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457517 SpdySession::PumpWriteLoop"));
   CHECK(!in_io_loop_);
   DCHECK_EQ(write_state_, expected_write_state);
 
   DoWriteLoop(expected_write_state, result);
 
   if (availability_state_ == STATE_DRAINING && !in_flight_write_ &&
       write_queue_.IsEmpty()) {
     pool_->RemoveUnavailableSession(GetWeakPtr());  // Destroys |this|.
     return;
   }
@@ skipping 31 matching lines @@
       break;
   }
 
   CHECK(in_io_loop_);
   in_io_loop_ = false;
 
   return result;
 }
 
 int SpdySession::DoWrite() {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457517 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457517 SpdySession::DoWrite"));
   CHECK(in_io_loop_);
 
   DCHECK(buffered_spdy_framer_);
   if (in_flight_write_) {
     DCHECK_GT(in_flight_write_->GetRemainingSize(), 0u);
   } else {
     // Grab the next frame to send.
     SpdyFrameType frame_type = DATA;
     scoped_ptr<SpdyBufferProducer> producer;
     base::WeakPtr<SpdyStream> stream;
@@ skipping 43 matching lines @@
   scoped_refptr<IOBuffer> write_io_buffer =
       in_flight_write_->GetIOBufferForRemainingData();
   return connection_->socket()->Write(
       write_io_buffer.get(),
       in_flight_write_->GetRemainingSize(),
       base::Bind(&SpdySession::PumpWriteLoop,
                  weak_factory_.GetWeakPtr(), WRITE_STATE_DO_WRITE_COMPLETE));
 }
 
 int SpdySession::DoWriteComplete(int result) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457517 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457517 SpdySession::DoWriteComplete"));
   CHECK(in_io_loop_);
   DCHECK_NE(result, ERR_IO_PENDING);
   DCHECK_GT(in_flight_write_->GetRemainingSize(), 0u);
 
   last_activity_time_ = time_func_();
 
   if (result < 0) {
     DCHECK_NE(result, ERR_IO_PENDING);
     in_flight_write_.reset();
     in_flight_write_frame_type_ = DATA;
@@ skipping 47 matching lines @@
 
 void SpdySession::DcheckDraining() const {
   DcheckGoingAway();
   DCHECK_EQ(availability_state_, STATE_DRAINING);
   DCHECK(active_streams_.empty());
   DCHECK(unclaimed_pushed_streams_.empty());
 }
 
 void SpdySession::StartGoingAway(SpdyStreamId last_good_stream_id,
                                  Error status) {
+  // TODO(pkasting): Remove ScopedTracker below once crbug.com/457517 is fixed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("457517 SpdySession::StartGoingAway"));
   DCHECK_GE(availability_state_, STATE_GOING_AWAY);
 
   // The loops below are carefully written to avoid reentrancy problems.
 
   while (true) {
     size_t old_size = GetTotalSize(pending_create_stream_queues_);
     base::WeakPtr<SpdyStreamRequest> pending_request =
         GetNextPendingStreamRequest();
     if (!pending_request)
       break;
@@ skipping 99 matching lines @@
   // stream isn't active (i.e., it hasn't written anything to the wire
   // yet) then it's as if it never existed. If it is active, then
   // LogAbandonedActiveStream() will increment the counters.
 }
 
 void SpdySession::LogAbandonedActiveStream(ActiveStreamMap::const_iterator it,
                                            Error status) {
   DCHECK_GT(it->first, 0u);
   LogAbandonedStream(it->second.stream, status);
   ++streams_abandoned_count_;
-  base::StatsCounter abandoned_streams("spdy.abandoned_streams");
-  abandoned_streams.Increment();
   if (it->second.stream->type() == SPDY_PUSH_STREAM &&
       unclaimed_pushed_streams_.find(it->second.stream->url()) !=
       unclaimed_pushed_streams_.end()) {
-    base::StatsCounter abandoned_push_streams("spdy.abandoned_push_streams");
-    abandoned_push_streams.Increment();
   }
 }
 
 SpdyStreamId SpdySession::GetNewStreamId() {
   CHECK_LE(stream_hi_water_mark_, kLastStreamId);
   SpdyStreamId id = stream_hi_water_mark_;
   stream_hi_water_mark_ += 2;
   return id;
 }
 
@@ skipping 167 matching lines @@
 
   write_queue_.RemovePendingWritesForStream(stream->GetWeakPtr());
   stream->OnClose(status);
 
   if (availability_state_ == STATE_AVAILABLE) {
     ProcessPendingStreamRequests();
   }
 }
 
 base::WeakPtr<SpdyStream> SpdySession::GetActivePushStream(const GURL& url) {
-  base::StatsCounter used_push_streams("spdy.claimed_push_streams");
-
   PushedStreamMap::iterator unclaimed_it = unclaimed_pushed_streams_.find(url);
   if (unclaimed_it == unclaimed_pushed_streams_.end())
     return base::WeakPtr<SpdyStream>();
 
   SpdyStreamId stream_id = unclaimed_it->second.stream_id;
   unclaimed_pushed_streams_.erase(unclaimed_it);
 
   ActiveStreamMap::iterator active_it = active_streams_.find(stream_id);
   if (active_it == active_streams_.end()) {
     NOTREACHED();
     return base::WeakPtr<SpdyStream>();
   }
 
   net_log_.AddEvent(NetLog::TYPE_SPDY_STREAM_ADOPTED_PUSH_STREAM,
                     base::Bind(&NetLogSpdyAdoptedPushStreamCallback,
                                active_it->second.stream->stream_id(), &url));
-  used_push_streams.Increment();
   return active_it->second.stream->GetWeakPtr();
 }
 
 bool SpdySession::GetSSLInfo(SSLInfo* ssl_info,
                              bool* was_npn_negotiated,
                              NextProto* protocol_negotiated) {
   *was_npn_negotiated = connection_->socket()->WasNpnNegotiated();
   *protocol_negotiated = connection_->socket()->GetNegotiatedProtocol();
   return connection_->socket()->GetSSLInfo(ssl_info);
 }
@@ skipping 254 matching lines @@
   if (!TryCreatePushStream(
           stream_id, associated_stream_id, priority, request_headers))
     return;
 
   ActiveStreamMap::iterator active_it = active_streams_.find(stream_id);
   if (active_it == active_streams_.end()) {
     NOTREACHED();
     return;
   }
 
-  if (OnInitialResponseHeadersReceived(response_headers,
-                                       response_time,
-                                       recv_first_byte_time,
-                                       active_it->second.stream) != OK)
-    return;
-
-  base::StatsCounter push_requests("spdy.pushed_streams");
-  push_requests.Increment();
+  OnInitialResponseHeadersReceived(response_headers, response_time,
+                                   recv_first_byte_time,
+                                   active_it->second.stream);
 }
 
 void SpdySession::DeleteExpiredPushedStreams() {
   if (unclaimed_pushed_streams_.empty())
     return;
 
   // Check that adequate time has elapsed since the last sweep.
   if (time_func_() < next_unclaimed_push_stream_sweep_time_)
     return;
 
@@ skipping 475 matching lines @@
                       base::Bind(&NetLogSpdyPushPromiseReceivedCallback,
                                  &headers,
                                  stream_id,
                                  promised_stream_id));
   }
 
   // Any priority will do.
   // TODO(baranovich): pass parent stream id priority?
   if (!TryCreatePushStream(promised_stream_id, stream_id, 0, headers))
     return;
-
-  base::StatsCounter push_requests("spdy.pushed_streams");
-  push_requests.Increment();
 }
 
 void SpdySession::SendStreamWindowUpdate(SpdyStreamId stream_id,
                                          uint32 delta_window_size) {
   CHECK_GE(flow_control_state_, FLOW_CONTROL_STREAM);
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   CHECK(it != active_streams_.end());
   CHECK_EQ(it->second.stream->stream_id(), stream_id);
   SendWindowUpdateFrame(
       stream_id, delta_window_size, it->second.stream->priority());
@@ skipping 517 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net