Fix bug which caused DNS time not to be reported by LoadTimingObserver.

chrome/browser/net/load_timing_observer.cc

 // Copyright (c) 2010 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 "chrome/browser/net/load_timing_observer.h"
 
 #include "base/compiler_specific.h"
 #include "base/time.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_netlog_params.h"
@@ skipping 30 matching lines @@
 }
 
 }
 
 LoadTimingObserver::URLRequestRecord::URLRequestRecord()
     : connect_job_id(net::NetLog::Source::kInvalidId),
       socket_log_id(net::NetLog::Source::kInvalidId),
       socket_reused(false) {
 }
 
-LoadTimingObserver::LoadTimingObserver() {
+LoadTimingObserver::LoadTimingObserver()
+    : last_connect_job_id_(net::NetLog::Source::kInvalidId) {
 }
 
 LoadTimingObserver::~LoadTimingObserver() {
 }
 
 LoadTimingObserver::URLRequestRecord*
 LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
   URLRequestToRecordMap::iterator it = url_request_to_record_.find(source_id);
   if (it != url_request_to_record_.end())
     return &it->second;
@@ skipping 49 matching lines @@
       url_request_to_record_.erase(source.id);
     return;
   }
 
   URLRequestRecord* record = GetURLRequestRecord(source.id);
   if (!record)
     return;
 
   ResourceLoaderBridge::LoadTimingInfo& timing = record->timing;
 
-  switch(type) {
+  switch (type) {
     case net::NetLog::TYPE_PROXY_SERVICE:
       if (is_begin)
         timing.proxy_start = TimeTicksToOffset(time, record);
       else if (is_end)
         timing.proxy_end = TimeTicksToOffset(time, record);
       break;
     case net::NetLog::TYPE_SOCKET_POOL:
       if (is_begin)
         timing.connect_start = TimeTicksToOffset(time, record);
       else if (is_end)
         timing.connect_end = TimeTicksToOffset(time, record);
       break;
     case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB:
       {
         uint32 connect_job_id = static_cast<net::NetLogSourceParameter*>(
             params)->value().id;
-        ConnectJobToRecordMap::iterator it =
-            connect_job_to_record_.find(connect_job_id);
-        if (it != connect_job_to_record_.end() &&
-                !it->second.dns_start.is_null()) {
-          timing.dns_start = TimeTicksToOffset(it->second.dns_start, record);
-          timing.dns_end = TimeTicksToOffset(it->second.dns_end, record);
+        if (last_connect_job_id_ == connect_job_id &&
+            !last_connect_job_record_.dns_start.is_null()) {
+          timing.dns_start =
+              TimeTicksToOffset(last_connect_job_record_.dns_start, record);
+          timing.dns_end =
+              TimeTicksToOffset(last_connect_job_record_.dns_end, record);
         }
       }
       break;
     case net::NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET:
       record->socket_reused = true;
       break;
     case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET:
       record->socket_log_id = static_cast<net::NetLogSourceParameter*>(
           params)->value().id;
       if (!record->socket_reused) {
         SocketToRecordMap::iterator it =
             socket_to_record_.find(record->socket_log_id);
         if (it != socket_to_record_.end() && !it->second.ssl_start.is_null()) {
-            timing.ssl_start = TimeTicksToOffset(it->second.ssl_start, record);
-            timing.ssl_end = TimeTicksToOffset(it->second.ssl_end, record);
+          timing.ssl_start = TimeTicksToOffset(it->second.ssl_start, record);
+          timing.ssl_end = TimeTicksToOffset(it->second.ssl_end, record);
         }
       }
       break;
     case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST:
     case net::NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST:
       if (is_begin)
         timing.send_start = TimeTicksToOffset(time, record);
       else if (is_end)
         timing.send_end = TimeTicksToOffset(time, record);
       break;
@@ skipping 25 matching lines @@
       // something went wrong. Should not happen.
       if (connect_job_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer connect job count has grown "
                         "larger than expected, resetting";
         connect_job_to_record_.clear();
       }
 
       connect_job_to_record_.insert(
           std::make_pair(source.id, ConnectJobRecord()));
     } else if (is_end) {
-      connect_job_to_record_.erase(source.id);
+      ConnectJobToRecordMap::iterator it =
+          connect_job_to_record_.find(source.id);
+      if (it != connect_job_to_record_.end()) {
+        last_connect_job_id_ = it->first;
+        last_connect_job_record_ = it->second;
+        connect_job_to_record_.erase(it);
+      }
     }
   } else if (type == net::NetLog::TYPE_HOST_RESOLVER_IMPL) {
     ConnectJobToRecordMap::iterator it =
         connect_job_to_record_.find(source.id);
     if (it != connect_job_to_record_.end()) {
       if (is_begin)
         it->second.dns_start = time;
       else if (is_end)
         it->second.dns_end = time;
     }
@@ skipping 31 matching lines @@
   if (it == socket_to_record_.end())
     return;
 
   if (type == net::NetLog::TYPE_SSL_CONNECT) {
     if (is_begin)
       it->second.ssl_start = time;
     else if (is_end)
       it->second.ssl_end = time;
   }
 }