Add new text for indicating we are resolving hosts during proxy resolution.

net/proxy/proxy_resolver_v8.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <cstdio>
 
 #include "net/proxy/proxy_resolver_v8.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
+#include "base/synchronization/lock.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_request_context.h"
@@ skipping 303 matching lines @@
   return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
 }
 
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
   explicit Context(ProxyResolverJSBindings* js_bindings)
-      : js_bindings_(js_bindings) {
+      : is_resolving_host_(false),
+        js_bindings_(js_bindings) {
     DCHECK(js_bindings != NULL);
   }
 
   ~Context() {
     v8::Locker locked;
 
     v8_this_.Dispose();
     v8_context_.Dispose();
 
     // Run the V8 garbage collector. We do this to be sure the
@@ skipping 139 matching lines @@
   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())
       ;
   }
 
+  bool is_resolving_host() const {
+    base::AutoLock auto_lock(lock_);
+    return is_resolving_host_;
+  }
+
  private:
+  class ScopedHostResolve {
+   public:
+    explicit ScopedHostResolve(Context* context)
+        : context_(context) {
+      context_->BeginHostResolve();
+    }
+
+    ~ScopedHostResolve() {
+      context_->EndHostResolve();
+    }
+
+   private:
+    Context* const context_;
+    DISALLOW_COPY_AND_ASSIGN(ScopedHostResolve);
+  };
+
+  void BeginHostResolve() {
+    base::AutoLock auto_lock(lock_);
+    DCHECK(!is_resolving_host_);
+    is_resolving_host_ = true;
+  }
+
+  void EndHostResolve() {
+    base::AutoLock auto_lock(lock_);
+    DCHECK(is_resolving_host_);
+    is_resolving_host_ = false;
+  }
+
   bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
     *function = v8_context_->Global()->Get(
         ASCIILiteralToV8String("FindProxyForURL"));
     return (*function)->IsFunction();
   }
 
   // Handle an exception thrown by V8.
   void HandleError(v8::Handle<v8::Message> message) {
     if (message.IsEmpty())
       return;
@@ skipping 50 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;
     bool success;
 
     {
       v8::Unlocker unlocker;
+      ScopedHostResolve scoped_host_resolve(context);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       success = context->js_bindings_->MyIpAddress(&result);
     }
 
     if (!success)
       return ASCIILiteralToV8String("127.0.0.1");
     return ASCIIStringToV8String(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 ip_address_list;
     bool success;
 
     {
       v8::Unlocker unlocker;
+      ScopedHostResolve scoped_host_resolve(context);
 
       // We shouldn't be called with any arguments, but will not complain if
       // we are.
       success = context->js_bindings_->MyIpAddressEx(&ip_address_list);
     }
 
     if (!success)
       ip_address_list = std::string();
     return ASCIIStringToV8String(ip_address_list);
   }
 
   // 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.
     std::string hostname;
     if (!GetHostnameArgument(args, &hostname))
       return v8::Null();
 
     std::string ip_address;
     bool success;
 
     {
       v8::Unlocker unlocker;
+      ScopedHostResolve scoped_host_resolve(context);
       success = context->js_bindings_->DnsResolve(hostname, &ip_address);
     }
 
     return success ? ASCIIStringToV8String(ip_address) : v8::Null();
   }
 
   // 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.
     std::string hostname;
     if (!GetHostnameArgument(args, &hostname))
       return v8::Undefined();
 
     std::string ip_address_list;
     bool success;
 
     {
       v8::Unlocker unlocker;
+      ScopedHostResolve scoped_host_resolve(context);
       success = context->js_bindings_->DnsResolveEx(hostname, &ip_address_list);
     }
 
     if (!success)
       ip_address_list = std::string();
 
     return ASCIIStringToV8String(ip_address_list);
   }
 
   // V8 callback for when "sortIpAddressList()" is invoked by the PAC script.
@@ skipping 22 matching lines @@
 
     std::string ip_address = V8StringToUTF8(args[0]->ToString());
     if (!IsStringASCII(ip_address))
       return v8::False();
     std::string ip_prefix = V8StringToUTF8(args[1]->ToString());
     if (!IsStringASCII(ip_prefix))
       return v8::False();
     return IsInNetEx(ip_address, ip_prefix) ? v8::True() : v8::False();
   }
 
+  mutable base::Lock lock_;
+  bool is_resolving_host_;
   ProxyResolverJSBindings* js_bindings_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
 ProxyResolverV8::ProxyResolverV8(
     ProxyResolverJSBindings* custom_js_bindings)
     : ProxyResolver(true /*expects_pac_bytes*/),
@@ skipping 31 matching lines @@
   context_->SetCurrentRequestContext(NULL);
 
   return rv;
 }
 
 void ProxyResolverV8::CancelRequest(RequestHandle request) {
   // This is a synchronous ProxyResolver; no possibility for async requests.
   NOTREACHED();
 }
 
+LoadState ProxyResolverV8::GetLoadState(RequestHandle request) const {
+  NOTREACHED();
+  return LOAD_STATE_IDLE;
+}
+
+LoadState ProxyResolverV8::GetLoadStateThreadSafe(RequestHandle request) const {
+  if (context_->is_resolving_host())
+    return LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT;
+  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+}
+
 void ProxyResolverV8::CancelSetPacScript() {
   NOTREACHED();
 }
 
 void ProxyResolverV8::PurgeMemory() {
   context_->PurgeMemory();
 }
 
 void ProxyResolverV8::Shutdown() {
   js_bindings_->Shutdown();
 }
 
 int ProxyResolverV8::SetPacScript(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     OldCompletionCallback* /*callback*/) {
   DCHECK(script_data.get());
   context_.reset();
   if (script_data->utf16().empty())
     return ERR_PAC_SCRIPT_FAILED;
 
   // Try parsing the PAC script.
   scoped_ptr<Context> context(new Context(js_bindings_.get()));
   int rv = context->InitV8(script_data);
   if (rv == OK)
     context_.reset(context.release());
   return rv;
 }
 
 }  // namespace net