Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/proxy/proxy_resolver_js_bindings.cc

-// Copyright (c) 2009 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.
+// 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_resolver_js_bindings.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/waitable_event.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 
 namespace net {
 namespace {
 
 // Wrapper around HostResolver to give a sync API while running the resolve
 // in async mode on |host_resolver_loop|. If |host_resolver_loop| is NULL,
 // runs sync on the current thread (this mode is just used by testing).
 class SyncHostResolverBridge
@@ skipping 11 matching lines @@
   // Run the resolve on host_resolver_loop, and wait for result.
   int Resolve(const std::string& hostname,
               AddressFamily address_family,
               net::AddressList* addresses) {
     // Port number doesn't matter.
     HostResolver::RequestInfo info(hostname, 80);
     info.set_address_family(address_family);
 
     // Hack for tests -- run synchronously on current thread.
     if (!host_resolver_loop_)
-      return host_resolver_->Resolve(info, addresses, NULL, NULL, NULL);
+      return host_resolver_->Resolve(info, addresses, NULL, NULL,
+                                     BoundNetLog());
 
     // Otherwise start an async resolve on the resolver's thread.
     host_resolver_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
         &SyncHostResolverBridge::StartResolve, info, addresses));
 
     // Wait for the resolve to complete in the resolver's thread.
     event_.Wait();
     return err_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<SyncHostResolverBridge>;
 
   ~SyncHostResolverBridge() {}
 
   // Called on host_resolver_loop_.
   void StartResolve(const HostResolver::RequestInfo& info,
                     net::AddressList* addresses) {
     DCHECK_EQ(host_resolver_loop_, MessageLoop::current());
     int error = host_resolver_->Resolve(
-        info, addresses, &callback_, NULL, NULL);
+        info, addresses, &callback_, NULL, BoundNetLog());
     if (error != ERR_IO_PENDING)
       OnResolveCompletion(error);  // Completed synchronously.
   }
 
   // Called on host_resolver_loop_.
   void OnResolveCompletion(int result) {
     DCHECK_EQ(host_resolver_loop_, MessageLoop::current());
     err_ = result;
     event_.Signal();
   }
@@ skipping 100 matching lines @@
 
 }  // namespace
 
 // static
 ProxyResolverJSBindings* ProxyResolverJSBindings::CreateDefault(
     HostResolver* host_resolver, MessageLoop* host_resolver_loop) {
   return new DefaultJSBindings(host_resolver, host_resolver_loop);
 }
 
 }  // namespace net