Update NetLog to be thread safe.

net/proxy/multi_threaded_proxy_resolver.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 "net/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/thread.h"
-#include "net/base/capturing_net_log.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/proxy/proxy_info.h"
 
 // TODO(eroman): Have the MultiThreadedProxyResolver clear its PAC script
 //               data when SetPacScript fails. That will reclaim memory when
 //               testing bogus scripts.
 
 namespace net {
 
 namespace {
 
@@ skipping 223 matching lines @@
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
         make_scoped_refptr(new NetLogIntegerParameter(
             "thread_number", executor()->thread_number())));
   }
 
   // Runs on the worker thread.
   virtual void Run(MessageLoop* origin_loop) {
-    const size_t kNetLogBound = 50u;
-    worker_log_.reset(new CapturingNetLog(kNetLogBound));
-    BoundNetLog bound_worker_log(NetLog::Source(), worker_log_.get());
-
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
-        url_, &results_buf_, NULL, NULL, bound_worker_log);
+        url_, &results_buf_, NULL, NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &GetProxyForURLJob::QueryComplete, rv));
   }
 
  private:
   // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code) {
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
-      // Merge the load log that was generated on the worker thread, into the
-      // main log.
-      CapturingBoundNetLog bound_worker_log(NetLog::Source(),
-                                            worker_log_.release());
-      bound_worker_log.AppendTo(net_log_);
-
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
       RunUserCallback(result_code);
     }
     OnJobCompleted();
   }
 
   // Must only be used on the "origin" thread.

[eroman, 2010/11/30 01:43:37]

This comment is no longer accurate (since |net_log_| is accessed from the worker
thread).

The assumption is that BoundNetLog is also thread safe; please update the
comment accordingly.

[mmenke, 2010/11/30 18:59:04]

Added a commend that net_log_ and url_ can be used from either thread, and left
in the old comment for results_.  url_ was mislabeled before.

   ProxyInfo* results_;
   BoundNetLog net_log_;
   const GURL url_;
 
   // Usable from within DoQuery on the worker thread.
   ProxyInfo results_buf_;
 
-  // Used to pass the captured events between DoQuery [worker thread] and
-  // QueryComplete [origin thread].
-  scoped_ptr<CapturingNetLog> worker_log_;
-
   bool was_waiting_for_thread_;
 };
 
 // MultiThreadedProxyResolver::Executor ----------------------------------------
 
 MultiThreadedProxyResolver::Executor::Executor(
     MultiThreadedProxyResolver* coordinator,
     ProxyResolver* resolver,
     int thread_number)
     : coordinator_(coordinator),
@@ skipping 256 matching lines @@
     return;
 
   // Get the next job to process (FIFO). Transfer it from the pending queue
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
   executor->StartJob(job);
 }
 
 }  // namespace net