Measure how often the users are encountering MD5...

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/client_socket_factory.h"
+#include "net/base/connection_type_histograms.h"
 #include "net/base/dns_resolution_observer.h"
 #include "net/base/host_resolver.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_client_socket.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_chunked_decoder.h"
 #include "net/http/http_network_session.h"
@@ skipping 32 matching lines @@
       read_buf_len_(0),
       next_state_(STATE_NONE) {
 #if defined(OS_WIN)
   // TODO(port): Port the SSLConfigService class to Linux and Mac OS X.
   session->ssl_config_service()->GetSSLConfig(&ssl_config_);
 #endif
 }
 
 int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   CompletionCallback* callback) {
+  UpdateConnectionTypeHistograms(CONNECTION_ANY);
+
   request_ = request_info;
 
   next_state_ = STATE_RESOLVE_PROXY;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartIgnoringLastError(
@@ skipping 972 matching lines @@
   } else {
     rv = error;
   }
 
   return rv;
 }
 
 void HttpNetworkTransaction::AddAuthorizationHeader(HttpAuth::Target target) {
   // If we have no authentication information, check if we can select
   // a cache entry preemptively (based on the path).
-  if(!HaveAuth(target) && !SelectPreemptiveAuth(target))
+  if (!HaveAuth(target) && !SelectPreemptiveAuth(target))
     return;
 
   DCHECK(HaveAuth(target));
 
   // Add a Authorization/Proxy-Authorization header line.
   std::string credentials = auth_handler_[target]->GenerateCredentials(
       auth_identity_[target].username,
       auth_identity_[target].password,
       request_,
       &proxy_info_);
@@ skipping 39 matching lines @@
   // the preemptively used auth entry matches the realm of the subsequent
   // challenge, then we can invalidate the preemptively used entry.
   // Otherwise as-is we may send the failed credentials one extra time.
   if (auth_identity_[target].source == HttpAuth::IDENT_SRC_PATH_LOOKUP)
     return;
 
   // Clear the cache entry for the identity we just failed on.
   // Note: we require the username/password to match before invalidating
   // since the entry in the cache may be newer than what we used last time.
   session_->auth_cache()->Remove(AuthOrigin(target),
-                                 auth_handler_[target]->realm(), 
+                                 auth_handler_[target]->realm(),
                                  auth_identity_[target].username,
                                  auth_identity_[target].password);
 }
 
 bool HttpNetworkTransaction::SelectPreemptiveAuth(HttpAuth::Target target) {
   DCHECK(!HaveAuth(target));
 
   // Don't do preemptive authorization if the URL contains a username/password,
   // since we must first be challenged in order to use the URL's identity.
   if (request_->url.has_username())
@@ skipping 130 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net