Add an additional per-request DNS cache when executing FindProxyForURL() from...

net/proxy/proxy_resolver_v8.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_resolver_v8.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
+#include "net/proxy/proxy_resolver_request_context.h"
 #include "net/proxy/proxy_resolver_script.h"
 #include "v8/include/v8.h"
 
 // Notes on the javascript environment:
 //
 // For the majority of the PAC utility functions, we use the same code
 // as Firefox. See the javascript library that proxy_resolver_scipt.h
 // pulls in.
 //
 // In addition, we implement a subset of Microsoft's extensions to PAC.
@@ skipping 183 matching lines @@
 
     // At a minimum, the FindProxyForURL() function must be defined for this
     // to be a legitimiate PAC script.
     v8::Local<v8::Value> function;
     if (!GetFindProxyForURL(&function))
       return ERR_PAC_SCRIPT_FAILED;
 
     return OK;
   }
 
-  void SetCurrentRequestNetLog(const BoundNetLog& net_log) {
-    current_request_net_log_ = net_log;
+  void SetCurrentRequestContext(ProxyResolverRequestContext* context) {
+    js_bindings_->set_current_request_context(context);
   }
 
   void PurgeMemory() {
     v8::Locker locked;
     // Repeatedly call the V8 idle notification until it returns true ("nothing
     // more to free").  Note that it makes more sense to do this than to
     // implement a new "delete everything" pass because object references make
     // it difficult to free everything possible in just one pass.
     while (!v8::V8::IdleNotification())
       ;
@@ skipping 62 matching lines @@
   // V8 callback for when "myIpAddress()" is invoked by the PAC script.
   static v8::Handle<v8::Value> MyIpAddressCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     std::string result;
 
     {
       v8::Unlocker unlocker;
 
-      context->current_request_net_log_.BeginEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_BEGIN,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS,
+                               NULL);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       result = context->js_bindings_->MyIpAddress();
 
-      context->current_request_net_log_.EndEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_END,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS,
+                               NULL);
     }
 
     if (result.empty())
       result = "127.0.0.1";
     return StdStringToV8String(result);
   }
 
   // V8 callback for when "myIpAddressEx()" is invoked by the PAC script.
   static v8::Handle<v8::Value> MyIpAddressExCallback(
       const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     std::string result;
 
     {
       v8::Unlocker unlocker;
 
-      context->current_request_net_log_.BeginEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS_EX, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_BEGIN,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS_EX,
+                               NULL);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       context->js_bindings_->MyIpAddressEx();
 
-      context->current_request_net_log_.EndEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS_EX, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_END,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_MY_IP_ADDRESS_EX,
+                               NULL);
     }
 
     return StdStringToV8String(result);
   }
 
   // V8 callback for when "dnsResolve()" is invoked by the PAC script.
   static v8::Handle<v8::Value> DnsResolveCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     // We need at least one string argument.
     if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
       return v8::Null();
     std::string host = V8StringToStdString(args[0]->ToString());
 
     std::string result;
 
     {
       v8::Unlocker unlocker;
 
-      context->current_request_net_log_.BeginEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_BEGIN,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE,
+                               NULL);
 
       result = context->js_bindings_->DnsResolve(host);
 
-      context->current_request_net_log_.EndEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_END,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE,
+                               NULL);
     }
 
     // DnsResolve() returns empty string on failure.
     return result.empty() ? v8::Null() : StdStringToV8String(result);
   }
 
   // V8 callback for when "dnsResolveEx()" is invoked by the PAC script.
   static v8::Handle<v8::Value> DnsResolveExCallback(const v8::Arguments& args) {
     Context* context =
         static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
 
     // We need at least one string argument.
     if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
       return v8::Undefined();
     std::string host = V8StringToStdString(args[0]->ToString());
 
     std::string result;
 
     {
       v8::Unlocker unlocker;
 
-      context->current_request_net_log_.BeginEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE_EX, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_BEGIN,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE_EX,
+                               NULL);
 
       result = context->js_bindings_->DnsResolveEx(host);
 
-      context->current_request_net_log_.EndEvent(
-          NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE_EX, NULL);
+      LogEventToCurrentRequest(context,
+                               NetLog::PHASE_END,
+                               NetLog::TYPE_PROXY_RESOLVER_V8_DNS_RESOLVE_EX,
+                               NULL);
     }
 
     return StdStringToV8String(result);
   }
 
+  static void LogEventToCurrentRequest(Context* context,
+                                       NetLog::EventPhase phase,
+                                       NetLog::EventType type,
+                                       NetLog::EventParameters* params) {
+    if (context->js_bindings_->current_request_context()) {
+      context->js_bindings_->current_request_context()->net_log->AddEntry(
+          type, phase, params);
+    }
+  }
+
   ProxyResolverJSBindings* js_bindings_;
-  BoundNetLog current_request_net_log_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
 ProxyResolverV8::ProxyResolverV8(
     ProxyResolverJSBindings* custom_js_bindings)
     : ProxyResolver(true /*expects_pac_bytes*/),
       js_bindings_(custom_js_bindings) {
 }
 
 ProxyResolverV8::~ProxyResolverV8() {}
 
 int ProxyResolverV8::GetProxyForURL(const GURL& query_url,
                                     ProxyInfo* results,
                                     CompletionCallback* /*callback*/,
                                     RequestHandle* /*request*/,
                                     const BoundNetLog& net_log) {
   // If the V8 instance has not been initialized (either because
   // SetPacScript() wasn't called yet, or because it failed.
   if (!context_.get())
     return ERR_FAILED;
 
+  // Associate some short-lived context with this request. This context will be
+  // available to any of the javascript "bindings" that are subsequently invoked
+  // from the javascript.
+  //
+  // In particular, we create a HostCache that is aggressive about caching
+  // failed DNS resolves.
+  HostCache host_cache(
+      50,
+      base::TimeDelta::FromMinutes(5),
+      base::TimeDelta::FromMinutes(5));
+
+  ProxyResolverRequestContext request_context(
+      &query_url, &net_log, &host_cache);
+
   // Otherwise call into V8.
-  context_->SetCurrentRequestNetLog(net_log);
+  context_->SetCurrentRequestContext(&request_context);
   int rv = context_->ResolveProxy(query_url, results);
-  context_->SetCurrentRequestNetLog(BoundNetLog());
+  context_->SetCurrentRequestContext(NULL);
 
   return rv;
 }
 
 void ProxyResolverV8::CancelRequest(RequestHandle request) {
   // This is a synchronous ProxyResolver; no possibility for async requests.
   NOTREACHED();
 }
 
 void ProxyResolverV8::PurgeMemory() {
   context_->PurgeMemory();
 }
 
 int ProxyResolverV8::SetPacScript(const GURL& /*url*/,
                                   const std::string& bytes_utf8,
                                   CompletionCallback* /*callback*/) {
   context_.reset();
   if (bytes_utf8.empty())
     return ERR_PAC_SCRIPT_FAILED;
 
   // Try parsing the PAC script.
   scoped_ptr<Context> context(new Context(js_bindings_.get()));
   int rv = context->InitV8(bytes_utf8);
   if (rv == OK)
     context_.reset(context.release());
   return rv;
 }
 
 }  // namespace net