Implement LoadLog, and hook up HostResolverImpl to LoadLog....

net/base/host_resolver_impl.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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>  // Needed for Win2k compat.
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #include <sys/socket.h>
 #endif
 #if defined(OS_LINUX)
 #include <resolv.h>
 #endif
 
 #include "base/compiler_specific.h"
 #include "base/debug_util.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/worker_pool.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver_proc.h"
+#include "net/base/load_log.h"
 #include "net/base/net_errors.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 HostResolver* CreateSystemHostResolver() {
   static const size_t kMaxHostCacheEntries = 100;
@@ skipping 10 matching lines @@
   } else {
     // Use the system procedure (getaddrinfo).
     return SystemHostResolverProc(host, out);
   }
 }
 
 //-----------------------------------------------------------------------------
 
 class HostResolverImpl::Request {
  public:
-  Request(int id, const RequestInfo& info, CompletionCallback* callback,
+  Request(LoadLog* load_log,
+          int id,
+          const RequestInfo& info,
+          CompletionCallback* callback,
           AddressList* addresses)
-      : id_(id), info_(info), job_(NULL), callback_(callback),
-        addresses_(addresses) {}
+      : load_log_(load_log),
+        id_(id),
+        info_(info),
+        job_(NULL),
+        callback_(callback),
+        addresses_(addresses) {
+  }
 
   // Mark the request as cancelled.
   void MarkAsCancelled() {
     job_ = NULL;
     callback_ = NULL;
     addresses_ = NULL;
   }
 
   bool was_cancelled() const {
     return callback_ == NULL;
@@ skipping 12 matching lines @@
   }
 
   int port() const {
     return info_.port();
   }
 
   Job* job() const {
     return job_;
   }
 
+  LoadLog* load_log() const {
+    return load_log_;
+  }
+
   int id() const {
     return id_;
   }
 
   const RequestInfo& info() const {
     return info_;
   }
 
  private:
+  scoped_refptr<LoadLog> load_log_;
+
   // Unique ID for this request. Used by observers to identify requests.
   int id_;
 
   // The request info that started the request.
   RequestInfo info_;
 
   // The resolve job (running in worker pool) that this request is dependent on.
   Job* job_;
 
   // The user's callback to invoke when the request completes.
@@ skipping 181 matching lines @@
                               const RequestInfo& info,
                               AddressList* addresses,
                               CompletionCallback* callback,
                               RequestHandle* out_req) {
   if (shutdown_)
     return ERR_UNEXPECTED;
 
   // Choose a unique ID number for observers to see.
   int request_id = next_request_id_++;
 
-  // Notify registered observers.
-  NotifyObserversStartRequest(request_id, info);
+  // Update the load log and notify registered observers.
+  OnStartRequest(load_log, request_id, info);
 
   // If we have an unexpired cache entry, use it.
   if (info.allow_cached_response()) {
     const HostCache::Entry* cache_entry = cache_.Lookup(
         info.hostname(), base::TimeTicks::Now());
     if (cache_entry) {
       addresses->SetFrom(cache_entry->addrlist, info.port());
       int error = cache_entry->error;
 
-      // Notify registered observers.
-      NotifyObserversFinishRequest(request_id, info, error);
+      // Update the load log and notify registered observers.
+      OnFinishRequest(load_log, request_id, info, error);
 
       return error;
     }
   }
 
   // If no callback was specified, do a synchronous resolution.
   if (!callback) {
     AddressList addrlist;
     int error = ResolveAddrInfo(
         effective_resolver_proc(), info.hostname(), &addrlist);
     if (error == OK) {
       addrlist.SetPort(info.port());
       *addresses = addrlist;
     }
 
     // Write to cache.
     cache_.Set(info.hostname(), error, addrlist, base::TimeTicks::Now());
 
-    // Notify registered observers.
-    NotifyObserversFinishRequest(request_id, info, error);
+    // Update the load log and notify registered observers.
+    OnFinishRequest(load_log, request_id, info, error);
 
     return error;
   }
 
   // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
-  Request* req = new Request(request_id, info, callback, addresses);
+  Request* req = new Request(load_log, request_id, info, callback, addresses);
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(req);
 
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
   scoped_refptr<Job> job;
 
   // If there is already an outstanding job to resolve |info.hostname()|, use
   // it. This prevents starting concurrent resolves for the same hostname.
   job = FindOutstandingJob(info.hostname());
@@ skipping 22 matching lines @@
     // |req_handle| is already cancelled.
     LOG(ERROR) << "Called HostResolverImpl::CancelRequest() after Shutdown().";
     StackTrace().PrintBacktrace();
     return;
   }
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
   DCHECK(req->job());
   // NULL out the fields of req, to mark it as cancelled.
   req->MarkAsCancelled();
-  NotifyObserversCancelRequest(req->id(), req->info());
+  OnCancelRequest(req->load_log(), req->id(), req->info());
 }
 
 void HostResolverImpl::AddObserver(Observer* observer) {
   observers_.push_back(observer);
 }
 
 void HostResolverImpl::RemoveObserver(Observer* observer) {
   ObserversList::iterator it =
       std::find(observers_.begin(), observers_.end(), observer);
 
@@ skipping 46 matching lines @@
   DCHECK(!cur_completing_job_);
   cur_completing_job_ = job;
 
   // Complete all of the requests that were attached to the job.
   for (RequestsList::const_iterator it = job->requests().begin();
        it != job->requests().end(); ++it) {
     Request* req = *it;
     if (!req->was_cancelled()) {
       DCHECK_EQ(job, req->job());
 
-      // Notify registered observers.
-      NotifyObserversFinishRequest(req->id(), req->info(), error);
+      // Update the load log and notify registered observers.
+      OnFinishRequest(req->load_log(), req->id(), req->info(), error);
 
       req->OnComplete(error, addrlist);
 
       // Check if the job was cancelled as a result of running the callback.
       // (Meaning that |this| was deleted).
       if (job->was_cancelled())
         return;
     }
   }
 
   cur_completing_job_ = NULL;
 }
 
-void HostResolverImpl::NotifyObserversStartRequest(int request_id,
-                                               const RequestInfo& info) {
-  for (ObserversList::iterator it = observers_.begin();
-       it != observers_.end(); ++it) {
-    (*it)->OnStartResolution(request_id, info);
+void HostResolverImpl::OnStartRequest(LoadLog* load_log,
+                                      int request_id,
+                                      const RequestInfo& info) {
+  LoadLog::BeginEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
+
+  // Notify the observers of the start.
+  if (!observers_.empty()) {
+    LoadLog::BeginEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART);
+
+    for (ObserversList::iterator it = observers_.begin();
+         it != observers_.end(); ++it) {
+      (*it)->OnStartResolution(request_id, info);
+    }
+
+    LoadLog::EndEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONSTART);
   }
 }
 
-void HostResolverImpl::NotifyObserversFinishRequest(int request_id,
-                                                const RequestInfo& info,
-                                                int error) {
-  bool was_resolved = error == OK;
-  for (ObserversList::iterator it = observers_.begin();
-       it != observers_.end(); ++it) {
-    (*it)->OnFinishResolutionWithStatus(request_id, was_resolved, info);
+void HostResolverImpl::OnFinishRequest(LoadLog* load_log,
+                                       int request_id,
+                                       const RequestInfo& info,
+                                       int error) {
+  // Notify the observers of the completion.
+  if (!observers_.empty()) {
+    LoadLog::BeginEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH);
+
+    bool was_resolved = error == OK;
+    for (ObserversList::iterator it = observers_.begin();
+         it != observers_.end(); ++it) {
+      (*it)->OnFinishResolutionWithStatus(request_id, was_resolved, info);
+    }
+
+    LoadLog::EndEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONFINISH);
   }
+
+  LoadLog::EndEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
-void HostResolverImpl::NotifyObserversCancelRequest(int request_id,
-                                                const RequestInfo& info) {
-  for (ObserversList::iterator it = observers_.begin();
-       it != observers_.end(); ++it) {
-    (*it)->OnCancelResolution(request_id, info);
+void HostResolverImpl::OnCancelRequest(LoadLog* load_log,
+                                       int request_id,
+                                       const RequestInfo& info) {
+  LoadLog::AddEvent(load_log, LoadLog::TYPE_CANCELLED);
+
+  // Notify the observers of the cancellation.
+  if (!observers_.empty()) {
+    LoadLog::BeginEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
+
+    for (ObserversList::iterator it = observers_.begin();
+         it != observers_.end(); ++it) {
+      (*it)->OnCancelResolution(request_id, info);
+    }
+
+    LoadLog::EndEvent(
+        load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
   }
+
+  LoadLog::EndEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
 }  // namespace net