Add a source to V8 proxy resolver-initiated DNS requests,

net/proxy/sync_host_resolver_bridge.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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/sync_host_resolver_bridge.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
 // SyncHostResolverBridge::Core ----------------------------------------------
 
 class SyncHostResolverBridge::Core
     : public base::RefCountedThreadSafe<SyncHostResolverBridge::Core> {
  public:
   Core(HostResolver* resolver, MessageLoop* host_resolver_loop);
 
   int ResolveSynchronously(const HostResolver::RequestInfo& info,
-                           AddressList* addresses);
+                           AddressList* addresses,
+                           const BoundNetLog& net_log);
 
   // Returns true if Shutdown() has been called.
   bool HasShutdown() const {
     base::AutoLock l(lock_);
     return HasShutdownLocked();
   }
 
   // Called on |host_resolver_loop_|.
   void Shutdown();
 
  private:
   friend class base::RefCountedThreadSafe<SyncHostResolverBridge::Core>;
 
   bool HasShutdownLocked() const {
     return has_shutdown_;
   }
 
   // Called on |host_resolver_loop_|.
   void StartResolve(const HostResolver::RequestInfo& info,
-                    AddressList* addresses);
+                    AddressList* addresses,
+                    const BoundNetLog& net_log);
 
   // Called on |host_resolver_loop_|.
   void OnResolveCompletion(int result);
 
   // Not called on |host_resolver_loop_|.
   int WaitForResolveCompletion();
 
   HostResolver* const host_resolver_;
   MessageLoop* const host_resolver_loop_;
   // The result from the current request (set on |host_resolver_loop_|).
@@ skipping 18 matching lines @@
                                    MessageLoop* host_resolver_loop)
     : host_resolver_(host_resolver),
       host_resolver_loop_(host_resolver_loop),
       err_(0),
       outstanding_request_(NULL),
       event_(true, false),
       has_shutdown_(false) {}
 
 int SyncHostResolverBridge::Core::ResolveSynchronously(
     const HostResolver::RequestInfo& info,
-    net::AddressList* addresses) {
+    net::AddressList* addresses,
+    const BoundNetLog& net_log) {
   // Otherwise start an async resolve on the resolver's thread.
   host_resolver_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&Core::StartResolve, this, info, addresses));
+      base::Bind(&Core::StartResolve, this, info, addresses, net_log));
 
   return WaitForResolveCompletion();
 }
 
 void SyncHostResolverBridge::Core::StartResolve(
     const HostResolver::RequestInfo& info,
-    net::AddressList* addresses) {
+    net::AddressList* addresses,
+    const BoundNetLog& net_log) {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
   DCHECK(!outstanding_request_);
 
   if (HasShutdown())
     return;
 
   int error = host_resolver_->Resolve(
       info, addresses, base::Bind(&Core::OnResolveCompletion, this),
-      &outstanding_request_, BoundNetLog());
+      &outstanding_request_, net_log);
   if (error != ERR_IO_PENDING)
     OnResolveCompletion(error);  // Completed synchronously.
 }
 
 void SyncHostResolverBridge::Core::OnResolveCompletion(int result) {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
   err_ = result;
   outstanding_request_ = NULL;
   event_.Signal();
 }
@@ skipping 36 matching lines @@
     : host_resolver_loop_(host_resolver_loop),
       core_(new Core(host_resolver, host_resolver_loop)) {
   DCHECK(host_resolver_loop_);
 }
 
 SyncHostResolverBridge::~SyncHostResolverBridge() {
   DCHECK(core_->HasShutdown());
 }
 
 int SyncHostResolverBridge::Resolve(const HostResolver::RequestInfo& info,
-                                    AddressList* addresses) {
-  return core_->ResolveSynchronously(info, addresses);
+                                    AddressList* addresses,
+                                    const BoundNetLog& net_log) {
+  return core_->ResolveSynchronously(info, addresses, net_log);
 }
 
 void SyncHostResolverBridge::Shutdown() {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
   core_->Shutdown();
 }
 
 }  // namespace net