Better match IE's proxy settings....

net/proxy/proxy_resolver_v8.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.
 
 #include "net/proxy/proxy_resolver_v8.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
@@ skipping 35 matching lines @@
   *result = V8StringToStdString(str_object);
   return true;
 }
 
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
-  Context(ProxyResolverJSBindings* js_bindings, const std::string& pac_data)
+  explicit Context(ProxyResolverJSBindings* js_bindings)
       : js_bindings_(js_bindings) {
     DCHECK(js_bindings != NULL);
-    InitV8(pac_data);
   }
 
   ~Context() {
     v8::Locker locked;
 
     v8_this_.Dispose();
     v8_context_.Dispose();
   }
 
   int ResolveProxy(const GURL& query_url, ProxyInfo* results) {
     v8::Locker locked;
     v8::HandleScope scope;
 
     v8::Context::Scope function_scope(v8_context_);
 
-    v8::Local<v8::Value> function =
-        v8_context_->Global()->Get(v8::String::New("FindProxyForURL"));
-    if (!function->IsFunction()) {
+    v8::Local<v8::Value> function;
+    if (!GetFindProxyForURL(&function)) {
       js_bindings_->OnError(-1, "FindProxyForURL() is undefined.");
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     v8::Handle<v8::Value> argv[] = {
       StdStringToV8String(query_url.spec()),
       StdStringToV8String(query_url.host()),
     };
 
     v8::TryCatch try_catch;
@@ skipping 10 matching lines @@
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     std::string ret_str = V8StringToStdString(ret->ToString());
 
     results->UsePacString(ret_str);
 
     return OK;
   }
 
- private:
-  void InitV8(const std::string& pac_data) {
+  int InitV8(const std::string& pac_data) {
     v8::Locker locked;
     v8::HandleScope scope;
 
     v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
     v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
 
     // Attach the javascript bindings.
     v8::Local<v8::FunctionTemplate> alert_template =
         v8::FunctionTemplate::New(&AlertCallback, v8_this_);
     global_template->Set(v8::String::New("alert"), alert_template);
@@ skipping 18 matching lines @@
     std::string text_raw = pac_data + PROXY_RESOLVER_SCRIPT;
     v8::Local<v8::String> text = StdStringToV8String(text_raw);
     v8::ScriptOrigin origin = v8::ScriptOrigin(
         v8::String::New(kPacResourceName));
     v8::Local<v8::Script> code = v8::Script::Compile(text, &origin);
 
     // Execute.
     if (!code.IsEmpty())
       code->Run();
 
-    if (try_catch.HasCaught())
+    if (try_catch.HasCaught()) {
       HandleError(try_catch.Message());
+      return ERR_PAC_SCRIPT_FAILED;
+    }
+
+    // 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;
+  }
+
+ private:
+  bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
+    *function = v8_context_->Global()->Get(v8::String::New("FindProxyForURL"));
+    return (*function)->IsFunction();
   }
 
   // Handle an exception thrown by V8.
   void HandleError(v8::Handle<v8::Message> message) {
     if (message.IsEmpty())
       return;
 
     // Otherwise dispatch to the bindings.
     int line_number = message->GetLineNumber();
     std::string error_message;
@@ skipping 66 matching lines @@
       js_bindings_(custom_js_bindings) {
 }
 
 ProxyResolverV8::~ProxyResolverV8() {}
 
 int ProxyResolverV8::GetProxyForURL(const GURL& query_url,
                                     ProxyInfo* results,
                                     CompletionCallback* /*callback*/,
                                     RequestHandle* /*request*/) {
   // If the V8 instance has not been initialized (either because
-  // SetPacScriptByData() wasn't called yet, or because it was called with
-  // empty string).
+  // SetPacScript() wasn't called yet, or because it failed.
   if (!context_.get())
     return ERR_FAILED;
 
   // Otherwise call into V8.
   return context_->ResolveProxy(query_url, results);
 }
 
 void ProxyResolverV8::CancelRequest(RequestHandle request) {
   // This is a synchronous ProxyResolver; no possibility for async requests.
   NOTREACHED();
 }
 
-void ProxyResolverV8::SetPacScriptByDataInternal(const std::string& data) {
+int ProxyResolverV8::SetPacScript(const GURL& /*url*/,
+                                  const std::string& bytes,
+                                  CompletionCallback* /*callback*/) {
   context_.reset();
-  if (!data.empty())
-    context_.reset(new Context(js_bindings_.get(), data));
+  if (bytes.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);
+  if (rv == OK)
+    context_.reset(context.release());
+  return rv;
 }
 
 }  // namespace net