Respect the charset specified in PAC file responses. ProxyScriptFetcher is no...

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/load_log.h"
@@ skipping 11 matching lines @@
 const char kPacResourceName[] = "proxy-pac-script.js";
 
 // Convert a V8 String to a std::string.
 std::string V8StringToStdString(v8::Handle<v8::String> s) {
   int len = s->Utf8Length();
   std::string result;
   s->WriteUtf8(WriteInto(&result, len + 1), len);
   return result;
 }
 
-// Convert a std::string to a V8 string.
+// Convert a std::string (UTF8) to a V8 string.
 v8::Local<v8::String> StdStringToV8String(const std::string& s) {
   return v8::String::New(s.data(), s.size());
 }
 
 // String-ize a V8 object by calling its toString() method. Returns true
 // on success. This may fail if the toString() throws an exception.
 bool V8ObjectToString(v8::Handle<v8::Value> object, std::string* result) {
   if (object.IsEmpty())
     return false;
 
@@ skipping 54 matching lines @@
       return ERR_PAC_SCRIPT_FAILED;
     }
 
     std::string ret_str = V8StringToStdString(ret->ToString());
 
     results->UsePacString(ret_str);
 
     return OK;
   }
 
-  int InitV8(const std::string& pac_data) {
+  int InitV8(const std::string& pac_data_utf8) {
     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);
 
     v8::Local<v8::FunctionTemplate> my_ip_address_template =
         v8::FunctionTemplate::New(&MyIpAddressCallback, v8_this_);
     global_template->Set(v8::String::New("myIpAddress"),
         my_ip_address_template);
 
     v8::Local<v8::FunctionTemplate> dns_resolve_template =
         v8::FunctionTemplate::New(&DnsResolveCallback, v8_this_);
     global_template->Set(v8::String::New("dnsResolve"),
         dns_resolve_template);
 
     v8_context_ = v8::Context::New(NULL, global_template);
 
     v8::Context::Scope ctx(v8_context_);
 
     v8::TryCatch try_catch;
 
     // Compile the script, including the PAC library functions.
-    std::string text_raw = pac_data + PROXY_RESOLVER_SCRIPT;
-    v8::Local<v8::String> text = StdStringToV8String(text_raw);
+    std::string text_raw_utf8 = pac_data_utf8 + PROXY_RESOLVER_SCRIPT;
+    v8::Local<v8::String> text = StdStringToV8String(text_raw_utf8);
     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()) {
       HandleError(try_catch.Message());
@@ skipping 129 matching lines @@
 
   return rv;
 }
 
 void ProxyResolverV8::CancelRequest(RequestHandle request) {
   // This is a synchronous ProxyResolver; no possibility for async requests.
   NOTREACHED();
 }
 
 int ProxyResolverV8::SetPacScript(const GURL& /*url*/,
-                                  const std::string& bytes,
+                                  const std::string& bytes_utf8,
                                   CompletionCallback* /*callback*/) {
   context_.reset();
-  if (bytes.empty())
+  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);
+  int rv = context->InitV8(bytes_utf8);
   if (rv == OK)
     context_.reset(context.release());
   return rv;
 }
 
 }  // namespace net