Make NetLog take in callbacks that return Values

chrome/browser/net/load_timing_observer.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 "chrome/browser/net/load_timing_observer.h"
 
 #include "base/time.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 65 matching lines @@
 LoadTimingObserver::URLRequestRecord*
 LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   URLRequestToRecordMap::iterator it = url_request_to_record_.find(source_id);
   if (it != url_request_to_record_.end())
     return &it->second;
   return NULL;
 }
 
-void LoadTimingObserver::OnAddEntry(net::NetLog::EventType type,
-                                    const base::TimeTicks& time,
-                                    const net::NetLog::Source& source,
-                                    net::NetLog::EventPhase phase,
-                                    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddEntry(const net::NetLog::Entry& entry) {
   // The events that the Observer is interested in only occur on the IO thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
     return;
-  if (source.type == net::NetLog::SOURCE_URL_REQUEST)
-    OnAddURLRequestEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
-    OnAddHTTPStreamJobEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_CONNECT_JOB)
-    OnAddConnectJobEntry(type, time, source, phase, params);
-  else if (source.type == net::NetLog::SOURCE_SOCKET)
-    OnAddSocketEntry(type, time, source, phase, params);
+  if (entry.source().type == net::NetLog::SOURCE_URL_REQUEST)
+    OnAddURLRequestEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
+    OnAddHTTPStreamJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_CONNECT_JOB)
+    OnAddConnectJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_SOCKET)
+    OnAddSocketEntry(entry);
 }
 
 // static
 void LoadTimingObserver::PopulateTimingInfo(
     net::URLRequest* request,
     content::ResourceResponse* response) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!(request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING))
     return;
 
   ChromeNetLog* chrome_net_log = static_cast<ChromeNetLog*>(
       request->net_log().net_log());
   if (chrome_net_log == NULL)
     return;
 
   uint32 source_id = request->net_log().source().id;
   LoadTimingObserver* observer = chrome_net_log->load_timing_observer();
   LoadTimingObserver::URLRequestRecord* record =
       observer->GetURLRequestRecord(source_id);
   if (record) {
     response->connection_id = record->socket_log_id;
     response->connection_reused = record->socket_reused;
     response->load_timing = record->timing;
   }
 }
 
-void LoadTimingObserver::OnAddURLRequestEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddURLRequestEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  if (type == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
+  if (entry.type() == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
     if (is_begin) {
       // Only record timing for entries with corresponding flag.
-      int load_flags =
-          static_cast<net::URLRequestStartEventParameters*>(params)->
-              load_flags();
+      int load_flags;
+      scoped_ptr<Value> event_parameters(entry.ParametersToValue());
+      if (!net::StartEventLoadFlagsFromEventParameters(
+              event_parameters.get(),
+              &load_flags)) {
+        NOTREACHED();
+        return;
+      }
+
       if (!(load_flags & net::LOAD_ENABLE_LOAD_TIMING))
         return;
 
       // Prevents us from passively growing the memory unbounded in case
       // something went wrong. Should not happen.
       if (url_request_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer url request count has grown "
                         "larger than expected, resetting";
         url_request_to_record_.clear();
       }
 
-      URLRequestRecord& record = url_request_to_record_[source.id];
-      record.base_ticks = time;
+      URLRequestRecord& record = url_request_to_record_[entry.source().id];
+      base::TimeTicks now = base::TimeTicks::Now();
+
+      record.base_ticks = now;
       record.timing = ResourceLoadTimingInfo();
-      record.timing.base_ticks = time;
-      record.timing.base_time = TimeTicksToTime(time);
+      record.timing.base_ticks = now;
+      record.timing.base_time = TimeTicksToTime(now);
     }
     return;
-  } else if (type == net::NetLog::TYPE_REQUEST_ALIVE) {
+  } else if (entry.type() == net::NetLog::TYPE_REQUEST_ALIVE) {
     // Cleanup records based on the TYPE_REQUEST_ALIVE entry.
     if (is_end)
-      url_request_to_record_.erase(source.id);
+      url_request_to_record_.erase(entry.source().id);
     return;
   }
 
-  URLRequestRecord* record = GetURLRequestRecord(source.id);
+  URLRequestRecord* record = GetURLRequestRecord(entry.source().id);
   if (!record)
     return;
 
   ResourceLoadTimingInfo& timing = record->timing;
 
-  switch (type) {
+  switch (entry.type()) {
     case net::NetLog::TYPE_PROXY_SERVICE:
       if (is_begin)
-        timing.proxy_start = TimeTicksToOffset(time, record);
+        timing.proxy_start = TimeTicksToOffset(base::TimeTicks::Now(), record);
       else if (is_end)
-        timing.proxy_end = TimeTicksToOffset(time, record);
+        timing.proxy_end = TimeTicksToOffset(base::TimeTicks::Now(), record);
       break;
     case net::NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB: {
-      uint32 http_stream_job_id = static_cast<net::NetLogSourceParameter*>(
-          params)->value().id;
+      net::NetLog::Source http_stream_job_source;
+      scoped_ptr<Value> event_parameters(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(
+              event_parameters.get(),
+              &http_stream_job_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_HTTP_STREAM_JOB,
+                http_stream_job_source.type);
+
       HTTPStreamJobToRecordMap::iterator it =
-          http_stream_job_to_record_.find(http_stream_job_id);
+          http_stream_job_to_record_.find(http_stream_job_source.id);
       if (it == http_stream_job_to_record_.end())
         return;
       if (!it->second.connect_start.is_null()) {
         timing.connect_start = TimeTicksToOffset(it->second.connect_start,
                                                  record);
       }
       if (!it->second.connect_end.is_null())
         timing.connect_end = TimeTicksToOffset(it->second.connect_end, record);
       if (!it->second.dns_start.is_null())
         timing.dns_start = TimeTicksToOffset(it->second.dns_start, record);
       if (!it->second.dns_end.is_null())
         timing.dns_end = TimeTicksToOffset(it->second.dns_end, record);
       if (!it->second.ssl_start.is_null())
         timing.ssl_start = TimeTicksToOffset(it->second.ssl_start, record);
       if (!it->second.ssl_end.is_null())
         timing.ssl_end = TimeTicksToOffset(it->second.ssl_end, record);
       record->socket_reused = it->second.socket_reused;
       record->socket_log_id = it->second.socket_log_id;
       break;
     }
     case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST:
       if (is_begin)
-        timing.send_start = TimeTicksToOffset(time, record);
+        timing.send_start = TimeTicksToOffset(base::TimeTicks::Now(), record);
       else if (is_end)
-        timing.send_end = TimeTicksToOffset(time, record);
+        timing.send_end = TimeTicksToOffset(base::TimeTicks::Now(), record);
       break;
     case net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS:
-      if (is_begin)
-        timing.receive_headers_start = TimeTicksToOffset(time, record);
-      else if (is_end)
-        timing.receive_headers_end = TimeTicksToOffset(time, record);
+      if (is_begin) {
+        timing.receive_headers_start =
+            TimeTicksToOffset(base::TimeTicks::Now(), record);
+      } else if (is_end) {
+        timing.receive_headers_end =
+            TimeTicksToOffset(base::TimeTicks::Now(), record);
+      }
       break;
     default:
       break;
   }
 }
 
 void LoadTimingObserver::OnAddHTTPStreamJobEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+    const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
-  if (type == net::NetLog::TYPE_HTTP_STREAM_JOB) {
+  if (entry.type() == net::NetLog::TYPE_HTTP_STREAM_JOB) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in
       // case something went wrong. Should not happen.
       if (http_stream_job_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer http stream job count "
                         "has grown larger than expected, resetting";
         http_stream_job_to_record_.clear();
       }
 
       http_stream_job_to_record_.insert(
-          std::make_pair(source.id, HTTPStreamJobRecord()));
+          std::make_pair(entry.source().id, HTTPStreamJobRecord()));
     } else if (is_end) {
-      http_stream_job_to_record_.erase(source.id);
+      http_stream_job_to_record_.erase(entry.source().id);
     }
     return;
   }
 
   HTTPStreamJobToRecordMap::iterator it =
-      http_stream_job_to_record_.find(source.id);
+      http_stream_job_to_record_.find(entry.source().id);
   if (it == http_stream_job_to_record_.end())
     return;
 
-  switch (type) {
+  switch (entry.type()) {
     case net::NetLog::TYPE_SOCKET_POOL:
       if (is_begin)
-        it->second.connect_start = time;
+        it->second.connect_start = base::TimeTicks::Now();
       else if (is_end)
-        it->second.connect_end = time;
+        it->second.connect_end = base::TimeTicks::Now();
       break;
     case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB: {
-      uint32 connect_job_id = static_cast<net::NetLogSourceParameter*>(
-          params)->value().id;
-      if (last_connect_job_id_ == connect_job_id &&
+      net::NetLog::Source connect_job_source;
+      scoped_ptr<Value> event_parameters(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(
+              event_parameters.get(),
+              &connect_job_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_CONNECT_JOB, connect_job_source.type);
+
+      if (last_connect_job_id_ == connect_job_source.id &&
           !last_connect_job_record_.dns_start.is_null()) {
         it->second.dns_start = last_connect_job_record_.dns_start;
         it->second.dns_end = last_connect_job_record_.dns_end;
       }
       break;
     }
     case net::NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET:
       it->second.socket_reused = true;
       break;
-    case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET:
-      it->second.socket_log_id = static_cast<net::NetLogSourceParameter*>(
-        params)->value().id;
+    case net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET: {
+      net::NetLog::Source socket_source;
+      scoped_ptr<Value> event_parameters(entry.ParametersToValue());
+      if (!net::NetLog::Source::FromEventParameters(
+              event_parameters.get(),
+              &socket_source)) {
+        NOTREACHED();
+        return;
+      }
+      DCHECK_EQ(net::NetLog::SOURCE_SOCKET, socket_source.type);
+
+      it->second.socket_log_id = socket_source.id;
       if (!it->second.socket_reused) {
         SocketToRecordMap::iterator socket_it =
             socket_to_record_.find(it->second.socket_log_id);
         if (socket_it != socket_to_record_.end() &&
             !socket_it->second.ssl_start.is_null()) {
           it->second.ssl_start = socket_it->second.ssl_start;
           it->second.ssl_end = socket_it->second.ssl_end;
         }
       }
       break;
+    }
     default:
       break;
   }
 }
 
-void LoadTimingObserver::OnAddConnectJobEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddConnectJobEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_POOL_CONNECT_JOB entry.
-  if (type == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB) {
+  if (entry.type() == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in case
       // 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()));
+          std::make_pair(entry.source().id, ConnectJobRecord()));
     } else if (is_end) {
       ConnectJobToRecordMap::iterator it =
-          connect_job_to_record_.find(source.id);
+          connect_job_to_record_.find(entry.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) {
+  } else if (entry.type() == net::NetLog::TYPE_HOST_RESOLVER_IMPL) {
     ConnectJobToRecordMap::iterator it =
-        connect_job_to_record_.find(source.id);
+        connect_job_to_record_.find(entry.source().id);
     if (it != connect_job_to_record_.end()) {
       if (is_begin)
-        it->second.dns_start = time;
+        it->second.dns_start = base::TimeTicks::Now();
       else if (is_end)
-        it->second.dns_end = time;
+        it->second.dns_end = base::TimeTicks::Now();
     }
   }
 }
 
-void LoadTimingObserver::OnAddSocketEntry(
-    net::NetLog::EventType type,
-    const base::TimeTicks& time,
-    const net::NetLog::Source& source,
-    net::NetLog::EventPhase phase,
-    net::NetLog::EventParameters* params) {
+void LoadTimingObserver::OnAddSocketEntry(const net::NetLog::Entry& entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool is_begin = phase == net::NetLog::PHASE_BEGIN;
-  bool is_end = phase == net::NetLog::PHASE_END;
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_ALIVE entry.
-  if (type == net::NetLog::TYPE_SOCKET_ALIVE) {
+  if (entry.type() == net::NetLog::TYPE_SOCKET_ALIVE) {
     if (is_begin) {
       // Prevents us from passively growing the memory unbounded in case
       // something went wrong. Should not happen.
       if (socket_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer socket count has grown "
                         "larger than expected, resetting";
         socket_to_record_.clear();
       }
 
       socket_to_record_.insert(
-          std::make_pair(source.id, SocketRecord()));
+          std::make_pair(entry.source().id, SocketRecord()));
     } else if (is_end) {
-      socket_to_record_.erase(source.id);
+      socket_to_record_.erase(entry.source().id);
     }
     return;
   }
-  SocketToRecordMap::iterator it = socket_to_record_.find(source.id);
+  SocketToRecordMap::iterator it = socket_to_record_.find(entry.source().id);
   if (it == socket_to_record_.end())
     return;
 
-  if (type == net::NetLog::TYPE_SSL_CONNECT) {
+  if (entry.type() == net::NetLog::TYPE_SSL_CONNECT) {
     if (is_begin)
-      it->second.ssl_start = time;
+      it->second.ssl_start = base::TimeTicks::Now();
     else if (is_end)
-      it->second.ssl_end = time;
+      it->second.ssl_end = base::TimeTicks::Now();
   }
 }