Remove Net.BlockedTunnelResponse histograms.

They aren't in histograms.xml, and that has been the case for multiple
years, so they're presumably safe to remove.

Bug: 643569
Change-Id: I262be8f7b4c97a6e85b1f58ddb54fe56dd67772b
Reviewed-on: https://chromium-review.googlesource.com/1053872Reviewed-by: Eric Roman <eroman@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#557610}

net/http/http_proxy_client_socket.cc

@@ -223,7 +223,6 @@ int HttpProxyClientSocket::Read(IOBuffer* buf,
     // We reach this case when the user cancels a 407 proxy auth prompt.
     // See http://crbug.com/8473.
     DCHECK_EQ(407, response_.headers->response_code());
-    LogBlockedTunnelResponse();
 
     return ERR_TUNNEL_CONNECTION_FAILED;
   }
@@ -301,12 +300,6 @@ int HttpProxyClientSocket::DidDrainBodyForAuthRestart() {
   return OK;
 }
 
-void HttpProxyClientSocket::LogBlockedTunnelResponse() const {
-  ProxyClientSocket::LogBlockedTunnelResponse(
-      response_.headers->response_code(),
-      is_https_proxy_);
-}
-
 void HttpProxyClientSocket::DoCallback(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
   DCHECK(!user_callback_.is_null());
@@ -470,10 +463,8 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
       // sanitize the response.  This still allows a rogue HTTPS proxy to
       // redirect an HTTPS site load to a similar-looking site, but no longer
       // allows it to impersonate the site the user requested.
-      if (!is_https_proxy_ || !SanitizeProxyRedirect(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!is_https_proxy_ || !SanitizeProxyRedirect(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
 
       redirect_has_load_timing_info_ = transport_->GetLoadTimingInfo(
           http_stream_parser_->IsConnectionReused(),
@@ -487,10 +478,8 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
       // authentication code is smart enough to avoid being tricked by an
       // active network attacker.
       // The next state is intentionally not set as it should be STATE_NONE;
-      if (!SanitizeProxyAuth(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!SanitizeProxyAuth(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
       return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
@@ -500,7 +489,6 @@ int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
       // 501 response bodies that contain a useful error message.  For
       // example, Squid uses a 404 response to report the DNS error: "The
       // domain name does not exist."
-      LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }

net/http/http_proxy_client_socket.h

@@ -114,8 +114,6 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocket : public ProxyClientSocket {
   int PrepareForAuthRestart();
   int DidDrainBodyForAuthRestart();
 
-  void LogBlockedTunnelResponse() const;
-
   void DoCallback(int result);
   void OnIOComplete(int result);
 

net/http/proxy_client_socket.cc

@@ -56,22 +56,6 @@ int ProxyClientSocket::HandleProxyAuthChallenge(
   return rv;
 }
 
-// static
-void ProxyClientSocket::LogBlockedTunnelResponse(int http_status_code,
-                                                 bool is_https_proxy) {
-  if (is_https_proxy) {
-    UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-        "Net.BlockedTunnelResponse.HttpsProxy",
-        HttpUtil::MapStatusCodeForHistogram(http_status_code),
-        HttpUtil::GetStatusCodesForHistogram());
-  } else {
-    UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-        "Net.BlockedTunnelResponse.HttpProxy",
-        HttpUtil::MapStatusCodeForHistogram(http_status_code),
-        HttpUtil::GetStatusCodesForHistogram());
-  }
-}
-
 // static
 bool ProxyClientSocket::SanitizeProxyAuth(HttpResponseInfo* response) {
   DCHECK(response && response->headers.get());

net/http/proxy_client_socket.h

@@ -74,10 +74,6 @@ class NET_EXPORT_PRIVATE ProxyClientSocket : public StreamSocket {
                                       HttpResponseInfo* response,
                                       const NetLogWithSource& net_log);
 
-  // Logs (to the log and in a histogram) a blocked CONNECT response.
-  static void LogBlockedTunnelResponse(int http_response_code,
-                                       bool is_https_proxy);
-
   // When a proxy authentication response is received during tunnel
   // construction, this method should be called to strip everything
   // but the auth header from the redirect response.  If it returns

net/quic/chromium/quic_proxy_client_socket.cc

@@ -270,12 +270,6 @@ int QuicProxyClientSocket::GetLocalAddress(IPEndPoint* address) const {
                        : ERR_SOCKET_NOT_CONNECTED;
 }
 
-void QuicProxyClientSocket::LogBlockedTunnelResponse() const {
-  ProxyClientSocket::LogBlockedTunnelResponse(
-      response_.headers->response_code(),
-      /* is_https_proxy = */ true);
-}
-
 void QuicProxyClientSocket::OnIOComplete(int result) {
   DCHECK_NE(STATE_DISCONNECTED, next_state_);
   int rv = DoLoop(result);
@@ -419,10 +413,8 @@ int QuicProxyClientSocket::DoReadReplyComplete(int result) {
     case 302:  // Found / Moved Temporarily
       // Try to return a sanitized response so we can follow auth redirects.
       // If we can't, fail the tunnel connection.
-      if (!SanitizeProxyRedirect(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!SanitizeProxyRedirect(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
       redirect_has_load_timing_info_ =
           GetLoadTimingInfo(&redirect_load_timing_info_);
       next_state_ = STATE_DISCONNECTED;
@@ -430,16 +422,13 @@ int QuicProxyClientSocket::DoReadReplyComplete(int result) {
 
     case 407:  // Proxy Authentication Required
       next_state_ = STATE_CONNECT_COMPLETE;
-      if (!SanitizeProxyAuth(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!SanitizeProxyAuth(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
       return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
       // Ignore response to avoid letting the proxy impersonate the target
       // server.  (See http://crbug.com/137891.)
-      LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }

net/quic/chromium/quic_proxy_client_socket.h

@@ -91,8 +91,6 @@ class NET_EXPORT_PRIVATE QuicProxyClientSocket : public ProxyClientSocket {
     STATE_CONNECT_COMPLETE
   };
 
-  void LogBlockedTunnelResponse() const;
-
   void OnIOComplete(int result);  // Callback used during connecting
   void OnReadComplete(int rv);
   void OnWriteComplete(int rv);

net/spdy/chromium/spdy_proxy_client_socket.cc

@@ -268,12 +268,6 @@ int SpdyProxyClientSocket::GetLocalAddress(IPEndPoint* address) const {
   return spdy_stream_->GetLocalAddress(address);
 }
 
-void SpdyProxyClientSocket::LogBlockedTunnelResponse() const {
-  ProxyClientSocket::LogBlockedTunnelResponse(
-      response_.headers->response_code(),
-      /* is_https_proxy = */ true);
-}
-
 void SpdyProxyClientSocket::RunCallback(CompletionOnceCallback callback,
                                         int result) const {
   std::move(callback).Run(result);
@@ -406,10 +400,8 @@ int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
     case 302:  // Found / Moved Temporarily
       // Try to return a sanitized response so we can follow auth redirects.
       // If we can't, fail the tunnel connection.
-      if (!SanitizeProxyRedirect(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!SanitizeProxyRedirect(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
 
       redirect_has_load_timing_info_ =
           spdy_stream_->GetLoadTimingInfo(&redirect_load_timing_info_);
@@ -420,16 +412,13 @@ int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
 
     case 407:  // Proxy Authentication Required
       next_state_ = STATE_OPEN;
-      if (!SanitizeProxyAuth(&response_)) {
-        LogBlockedTunnelResponse();
+      if (!SanitizeProxyAuth(&response_))
         return ERR_TUNNEL_CONNECTION_FAILED;
-      }
       return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_);
 
     default:
       // Ignore response to avoid letting the proxy impersonate the target
       // server.  (See http://crbug.com/137891.)
-      LogBlockedTunnelResponse();
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }

net/spdy/chromium/spdy_proxy_client_socket.h

@@ -116,8 +116,6 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
     STATE_CLOSED
   };
 
-  void LogBlockedTunnelResponse() const;
-
   // Calls |callback.Run(result)|. Used to run a callback posted to the
   // message loop.
   void RunCallback(CompletionOnceCallback callback, int result) const;