Make LoadLog refcounted-thread safe....

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)
@@ skipping 57 matching lines @@
         job_(NULL),
         callback_(callback),
         addresses_(addresses) {
   }
 
   // Mark the request as cancelled.
   void MarkAsCancelled() {
     job_ = NULL;
     callback_ = NULL;
     addresses_ = NULL;
-    // Clear the LoadLog to make sure it won't be released later on the
-    // worker thread. See http://crbug.com/22272
-    load_log_ = NULL;
   }
 
   bool was_cancelled() const {
     return callback_ == NULL;
   }
 
   void set_job(Job* job) {
     DCHECK(job != NULL);
     // Identify which job the request is waiting on.
     job_ = job;
@@ skipping 95 matching lines @@
     resolver_ = NULL;
 
     // Mark the job as cancelled, so when worker thread completes it will
     // not try to post completion to origin loop.
     {
       AutoLock locked(origin_loop_lock_);
       origin_loop_ = NULL;
     }
 
     // We will call HostResolverImpl::CancelRequest(Request*) on each one
-    // in order to notify any observers, and also clear the LoadLog.
+    // in order to notify any observers.
     for (RequestsList::const_iterator it = requests_.begin();
          it != requests_.end(); ++it) {
       HostResolverImpl::Request* req = *it;
       if (!req->was_cancelled())
         resolver->CancelRequest(req);
     }
   }
 
   // Called from origin thread.
   bool was_cancelled() const {
@@ skipping 196 matching lines @@
     // TODO(eroman): temp hack for: http://crbug.com/18373
     // Because we destroy outstanding requests during Shutdown(),
     // |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());
-  // Hold a reference to the request's load log as we are about to clear it.
-  scoped_refptr<LoadLog> load_log(req->load_log());
   // NULL out the fields of req, to mark it as cancelled.
   req->MarkAsCancelled();
-  OnCancelRequest(load_log, 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 30 matching lines @@
 }
 
 void HostResolverImpl::RemoveOutstandingJob(Job* job) {
   JobMap::iterator it = jobs_.find(job->key());
   DCHECK(it != jobs_.end());
   DCHECK_EQ(it->second.get(), job);
   jobs_.erase(it);
 }
 
 void HostResolverImpl::OnJobComplete(Job* job,
-                                 int error,
-                                 const AddressList& addrlist) {
+                                     int error,
+                                     const AddressList& addrlist) {
   RemoveOutstandingJob(job);
 
   // Write result to the cache.
   cache_.Set(job->key(), error, addrlist, base::TimeTicks::Now());
 
   // Make a note that we are executing within OnJobComplete() in case the
   // HostResolver is deleted by a callback invocation.
   DCHECK(!cur_completing_job_);
   cur_completing_job_ = job;
 
@@ skipping 77 matching lines @@
     }
 
     LoadLog::EndEvent(
         load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL_OBSERVER_ONCANCEL);
   }
 
   LoadLog::EndEvent(load_log, LoadLog::TYPE_HOST_RESOLVER_IMPL);
 }
 
 }  // namespace net