Update NetLog to be thread safe.

net/proxy/proxy_service.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/proxy_service.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/forwarding_net_log.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/proxy/init_proxy_resolver.h"
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #if defined(OS_WIN)
 #include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
@@ skipping 124 matching lines @@
 
  private:
   const std::string pac_string_;
 };
 
 // This factory creates V8ProxyResolvers with appropriate javascript bindings.
 class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
  public:
   // |async_host_resolver|, |io_loop| and |net_log| must remain
   // valid for the duration of our lifetime.
   // Both |async_host_resolver| and |net_log| will only be operated on

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

Please update this comment.

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

Done.

   // |io_loop|.
   ProxyResolverFactoryForV8(HostResolver* async_host_resolver,
                             MessageLoop* io_loop,
                             NetLog* net_log)
       : ProxyResolverFactory(true /*expects_pac_bytes*/),
         async_host_resolver_(async_host_resolver),
         io_loop_(io_loop),
-        forwarding_net_log_(
-            net_log ? new ForwardingNetLog(net_log, io_loop) : NULL) {
+        net_log_(net_log) {
   }
 
   virtual ProxyResolver* CreateProxyResolver() {
     // Create a synchronous host resolver wrapper that operates
     // |async_host_resolver_| on |io_loop_|.
     SyncHostResolverBridge* sync_host_resolver =
         new SyncHostResolverBridge(async_host_resolver_, io_loop_);
 
     ProxyResolverJSBindings* js_bindings =
-        ProxyResolverJSBindings::CreateDefault(sync_host_resolver,
-                                               forwarding_net_log_.get());
+        ProxyResolverJSBindings::CreateDefault(sync_host_resolver, net_log_);
 
     // ProxyResolverV8 takes ownership of |js_bindings|.
     return new ProxyResolverV8(js_bindings);
   }
 
  private:
   HostResolver* const async_host_resolver_;
   MessageLoop* io_loop_;
-
-  // Thread-safe wrapper around a non-threadsafe NetLog implementation. This
-  // enables the proxy resolver to emit log messages from the PAC thread.
-  scoped_ptr<ForwardingNetLog> forwarding_net_log_;
+  NetLog* net_log_;
 };
 
 // Creates ProxyResolvers using a platform-specific implementation.
 class ProxyResolverFactoryForSystem : public ProxyResolverFactory {
  public:
   ProxyResolverFactoryForSystem()
       : ProxyResolverFactory(false /*expects_pac_bytes*/) {}
 
   virtual ProxyResolver* CreateProxyResolver() {
     DCHECK(IsSupported());
@@ skipping 735 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net