proxy_resolver_v8.cc revision 86b75a5f88eda8b47d1e34e26dfc0210aec09367
1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <algorithm>
6#include <cstdio>
7#include <string>
8
9#include <utils/String16.h>
10
11#include "proxy_resolver_v8.h"
12
13#include "proxy_resolver_script.h"
14#include "net_util.h"
15#include <include/v8.h>
16#include <algorithm>
17#include <vector>
18
19#include <iostream>
20
21#include <string.h>
22#include <utils/String8.h>
23#include <utils/String16.h>
24
25// Notes on the javascript environment:
26//
27// For the majority of the PAC utility functions, we use the same code
28// as Firefox. See the javascript library that proxy_resolver_scipt.h
29// pulls in.
30//
31// In addition, we implement a subset of Microsoft's extensions to PAC.
32// - myIpAddressEx()
33// - dnsResolveEx()
34// - isResolvableEx()
35// - isInNetEx()
36// - sortIpAddressList()
37//
38// It is worth noting that the original PAC specification does not describe
39// the return values on failure. Consequently, there are compatibility
40// differences between browsers on what to return on failure, which are
41// illustrated below:
42//
43// --------------------+-------------+-------------------+--------------
44//                     | Firefox3    | InternetExplorer8 |  --> Us <---
45// --------------------+-------------+-------------------+--------------
46// myIpAddress()       | "127.0.0.1" |  ???              |  "127.0.0.1"
47// dnsResolve()        | null        |  false            |  null
48// myIpAddressEx()     | N/A         |  ""               |  ""
49// sortIpAddressList() | N/A         |  false            |  false
50// dnsResolveEx()      | N/A         |  ""               |  ""
51// isInNetEx()         | N/A         |  false            |  false
52// --------------------+-------------+-------------------+--------------
53//
54// TODO: The cell above reading ??? means I didn't test it.
55//
56// Another difference is in how dnsResolve() and myIpAddress() are
57// implemented -- whether they should restrict to IPv4 results, or
58// include both IPv4 and IPv6. The following table illustrates the
59// differences:
60//
61// --------------------+-------------+-------------------+--------------
62//                     | Firefox3    | InternetExplorer8 |  --> Us <---
63// --------------------+-------------+-------------------+--------------
64// myIpAddress()       | IPv4/IPv6   |  IPv4             |  IPv4
65// dnsResolve()        | IPv4/IPv6   |  IPv4             |  IPv4
66// isResolvable()      | IPv4/IPv6   |  IPv4             |  IPv4
67// myIpAddressEx()     | N/A         |  IPv4/IPv6        |  IPv4/IPv6
68// dnsResolveEx()      | N/A         |  IPv4/IPv6        |  IPv4/IPv6
69// sortIpAddressList() | N/A         |  IPv4/IPv6        |  IPv4/IPv6
70// isResolvableEx()    | N/A         |  IPv4/IPv6        |  IPv4/IPv6
71// isInNetEx()         | N/A         |  IPv4/IPv6        |  IPv4/IPv6
72// -----------------+-------------+-------------------+--------------
73
74static bool DoIsStringASCII(const android::String16& str) {
75  for (size_t i = 0; i < str.size(); i++) {
76    unsigned short c = str.string()[i];
77    if (c > 0x7F)
78      return false;
79  }
80  return true;
81}
82
83bool IsStringASCII(const android::String16& str) {
84  return DoIsStringASCII(str);
85}
86
87namespace net {
88
89namespace {
90
91// Pseudo-name for the PAC script.
92const char kPacResourceName[] = "proxy-pac-script.js";
93// Pseudo-name for the PAC utility script.
94const char kPacUtilityResourceName[] = "proxy-pac-utility-script.js";
95
96// External string wrapper so V8 can access the UTF16 string wrapped by
97// ProxyResolverScriptData.
98class V8ExternalStringFromScriptData
99    : public v8::String::ExternalStringResource {
100 public:
101  explicit V8ExternalStringFromScriptData(
102      const android::String16& script_data)
103      : script_data_(script_data) {}
104
105  virtual const uint16_t* data() const {
106    return script_data_.string();
107  }
108
109  virtual size_t length() const {
110    return script_data_.size();
111  }
112
113 private:
114  const android::String16& script_data_;
115//  DISALLOW_COPY_AND_ASSIGN(V8ExternalStringFromScriptData);
116};
117
118// External string wrapper so V8 can access a string literal.
119class V8ExternalASCIILiteral : public v8::String::ExternalAsciiStringResource {
120 public:
121  // |ascii| must be a NULL-terminated C string, and must remain valid
122  // throughout this object's lifetime.
123  V8ExternalASCIILiteral(const char* ascii, size_t length)
124      : ascii_(ascii), length_(length) {
125  }
126
127  virtual const char* data() const {
128    return ascii_;
129  }
130
131  virtual size_t length() const {
132    return length_;
133  }
134
135 private:
136  const char* ascii_;
137  size_t length_;
138};
139
140// When creating a v8::String from a C++ string we have two choices: create
141// a copy, or create a wrapper that shares the same underlying storage.
142// For small strings it is better to just make a copy, whereas for large
143// strings there are savings by sharing the storage. This number identifies
144// the cutoff length for when to start wrapping rather than creating copies.
145const size_t kMaxStringBytesForCopy = 256;
146
147template <class string_type>
148inline typename string_type::value_type* WriteInto(string_type* str,
149                                                   size_t length_with_null) {
150  str->reserve(length_with_null);
151  str->resize(length_with_null - 1);
152  return &((*str)[0]);
153}
154
155// Converts a V8 String to a UTF8 std::string.
156std::string V8StringToUTF8(v8::Handle<v8::String> s) {
157  std::string result;
158  s->WriteUtf8(WriteInto(&result, s->Length() + 1));
159  return result;
160}
161
162// Converts a V8 String to a UTF16 string.
163android::String16 V8StringToUTF16(v8::Handle<v8::String> s) {
164  int len = s->Length();
165  char16_t* buf = new char16_t[len + 1];
166  s->Write(buf, 0, len);
167  android::String16 ret(buf, len);
168  delete buf;
169  return ret;
170}
171
172std::string UTF16ToASCII(const android::String16& str) {
173    android::String8 rstr(str);
174    return std::string(rstr.string());
175}
176
177android::String16 ASCIIToUTF16(const std::string str) {
178  android::String8 str8(str.c_str());
179  return android::String16(str8);
180}
181
182// Converts an ASCII std::string to a V8 string.
183v8::Local<v8::String> ASCIIStringToV8String(const std::string& s) {
184  return v8::String::New(s.data(), s.size());
185}
186
187v8::Local<v8::String> UTF16StringToV8String(const android::String16& s) {
188  return v8::String::New(s.string(), s.size());
189}
190
191// Converts an ASCII string literal to a V8 string.
192v8::Local<v8::String> ASCIILiteralToV8String(const char* ascii) {
193//  DCHECK(IsStringASCII(ascii));
194  size_t length = strlen(ascii);
195  if (length <= kMaxStringBytesForCopy)
196    return v8::String::New(ascii, length);
197  return v8::String::NewExternal(new V8ExternalASCIILiteral(ascii, length));
198}
199
200// Stringizes a V8 object by calling its toString() method. Returns true
201// on success. This may fail if the toString() throws an exception.
202bool V8ObjectToUTF16String(v8::Handle<v8::Value> object,
203                           android::String16* utf16_result) {
204  if (object.IsEmpty())
205    return false;
206
207  v8::HandleScope scope;
208  v8::Local<v8::String> str_object = object->ToString();
209  if (str_object.IsEmpty())
210    return false;
211  *utf16_result = V8StringToUTF16(str_object);
212  return true;
213}
214
215// Extracts an hostname argument from |args|. On success returns true
216// and fills |*hostname| with the result.
217bool GetHostnameArgument(const v8::Arguments& args, std::string* hostname) {
218  // The first argument should be a string.
219  if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
220    return false;
221
222  const android::String16 hostname_utf16 = V8StringToUTF16(args[0]->ToString());
223
224  // If the hostname is already in ASCII, simply return it as is.
225  if (IsStringASCII(hostname_utf16)) {
226    *hostname = UTF16ToASCII(hostname_utf16);
227    return true;
228  }
229  return false;
230}
231
232// Wrapper for passing around IP address strings and IPAddressNumber objects.
233struct IPAddress {
234  IPAddress(const std::string& ip_string, const IPAddressNumber& ip_number)
235      : string_value(ip_string),
236        ip_address_number(ip_number) {
237  }
238
239  // Used for sorting IP addresses in ascending order in SortIpAddressList().
240  // IP6 addresses are placed ahead of IPv4 addresses.
241  bool operator<(const IPAddress& rhs) const {
242    const IPAddressNumber& ip1 = this->ip_address_number;
243    const IPAddressNumber& ip2 = rhs.ip_address_number;
244    if (ip1.size() != ip2.size())
245      return ip1.size() > ip2.size();  // IPv6 before IPv4.
246    return memcmp(&ip1[0], &ip2[0], ip1.size()) < 0;  // Ascending order.
247  }
248
249  std::string string_value;
250  IPAddressNumber ip_address_number;
251};
252
253template<typename STR>
254bool RemoveCharsT(const STR& input,
255                  const typename STR::value_type remove_chars[],
256                  STR* output) {
257  bool removed = false;
258  size_t found;
259
260  *output = input;
261
262  found = output->find_first_of(remove_chars);
263  while (found != STR::npos) {
264    removed = true;
265    output->replace(found, 1, STR());
266    found = output->find_first_of(remove_chars, found);
267  }
268
269  return removed;
270}
271
272bool RemoveChars(const std::string& input,
273                 const char remove_chars[],
274                 std::string* output) {
275  return RemoveCharsT(input, remove_chars, output);
276}
277
278// Handler for "sortIpAddressList(IpAddressList)". |ip_address_list| is a
279// semi-colon delimited string containing IP addresses.
280// |sorted_ip_address_list| is the resulting list of sorted semi-colon delimited
281// IP addresses or an empty string if unable to sort the IP address list.
282// Returns 'true' if the sorting was successful, and 'false' if the input was an
283// empty string, a string of separators (";" in this case), or if any of the IP
284// addresses in the input list failed to parse.
285bool SortIpAddressList(const std::string& ip_address_list,
286                       std::string* sorted_ip_address_list) {
287  sorted_ip_address_list->clear();
288
289  // Strip all whitespace (mimics IE behavior).
290  std::string cleaned_ip_address_list;
291  RemoveChars(ip_address_list, " \t", &cleaned_ip_address_list);
292  if (cleaned_ip_address_list.empty())
293    return false;
294
295  // Split-up IP addresses and store them in a vector.
296  std::vector<IPAddress> ip_vector;
297  IPAddressNumber ip_num;
298  char *tok_list = strtok((char *)cleaned_ip_address_list.c_str(), ";");
299  while (tok_list != NULL) {
300    if (!ParseIPLiteralToNumber(tok_list, &ip_num))
301      return false;
302    ip_vector.push_back(IPAddress(tok_list, ip_num));
303    tok_list = strtok(NULL, ";");
304  }
305
306  if (ip_vector.empty())  // Can happen if we have something like
307    return false;         // sortIpAddressList(";") or sortIpAddressList("; ;")
308
309  // Sort lists according to ascending numeric value.
310  if (ip_vector.size() > 1)
311    std::stable_sort(ip_vector.begin(), ip_vector.end());
312
313  // Return a semi-colon delimited list of sorted addresses (IPv6 followed by
314  // IPv4).
315  for (size_t i = 0; i < ip_vector.size(); ++i) {
316    if (i > 0)
317      *sorted_ip_address_list += ";";
318    *sorted_ip_address_list += ip_vector[i].string_value;
319  }
320  return true;
321}
322
323
324// Handler for "isInNetEx(ip_address, ip_prefix)". |ip_address| is a string
325// containing an IPv4/IPv6 address, and |ip_prefix| is a string containg a
326// slash-delimited IP prefix with the top 'n' bits specified in the bit
327// field. This returns 'true' if the address is in the same subnet, and
328// 'false' otherwise. Also returns 'false' if the prefix is in an incorrect
329// format, or if an address and prefix of different types are used (e.g. IPv6
330// address and IPv4 prefix).
331bool IsInNetEx(const std::string& ip_address, const std::string& ip_prefix) {
332  IPAddressNumber address;
333  if (!ParseIPLiteralToNumber(ip_address, &address))
334    return false;
335
336  IPAddressNumber prefix;
337  size_t prefix_length_in_bits;
338  if (!ParseCIDRBlock(ip_prefix, &prefix, &prefix_length_in_bits))
339    return false;
340
341  // Both |address| and |prefix| must be of the same type (IPv4 or IPv6).
342  if (address.size() != prefix.size())
343    return false;
344
345  return IPNumberMatchesPrefix(address, prefix, prefix_length_in_bits);
346}
347
348}  // namespace
349
350// ProxyResolverV8::Context ---------------------------------------------------
351
352class ProxyResolverV8::Context {
353 public:
354  explicit Context(ProxyResolverJSBindings* js_bindings,
355          ProxyErrorListener* error_listener)
356      : js_bindings_(js_bindings), error_listener_(error_listener) {
357  }
358
359  ~Context() {
360    v8::Locker locked;
361
362    v8_this_.Dispose();
363    v8_context_.Dispose();
364
365    // Run the V8 garbage collector. We do this to be sure the
366    // ExternalStringResource objects we allocated get properly disposed.
367    // Otherwise when running the unit-tests they may get leaked.
368    // See crbug.com/48145.
369    PurgeMemory();
370  }
371
372  int ResolveProxy(const android::String16 url, const android::String16 host, android::String16* results) {
373    v8::Locker locked;
374    v8::HandleScope scope;
375
376    v8::Context::Scope function_scope(v8_context_);
377
378    v8::Local<v8::Value> function;
379    if (!GetFindProxyForURL(&function)) {
380      *results = ASCIIToUTF16("FindProxyForURL() is undefined");
381      return ERR_PAC_SCRIPT_FAILED;
382    }
383
384    v8::Handle<v8::Value> argv[] = {
385        UTF16StringToV8String(url),
386        UTF16StringToV8String(host) };
387
388    v8::TryCatch try_catch;
389    v8::Local<v8::Value> ret = v8::Function::Cast(*function)->Call(
390        v8_context_->Global(), 2, argv);
391
392    if (try_catch.HasCaught()) {
393      *results = V8StringToUTF16(try_catch.Message()->Get());
394      return ERR_PAC_SCRIPT_FAILED;
395    }
396
397    if (!ret->IsString()) {
398      *results = ASCIIToUTF16("FindProxyForURL() did not return a string.");
399      return ERR_PAC_SCRIPT_FAILED;
400    }
401
402    *results = V8StringToUTF16(ret->ToString());
403
404    if (!IsStringASCII(*results)) {
405      // TODO:         Rather than failing when a wide string is returned, we
406      //               could extend the parsing to handle IDNA hostnames by
407      //               converting them to ASCII punycode.
408      //               crbug.com/47234
409      *results = ASCIIToUTF16("FindProxyForURL() returned a non-ASCII string");
410      return ERR_PAC_SCRIPT_FAILED;
411    }
412
413    return OK;
414  }
415
416  int InitV8(const android::String16& pac_script) {
417    v8::Locker locked;
418    v8::HandleScope scope;
419
420    v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
421    v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
422
423    // Attach the javascript bindings.
424    v8::Local<v8::FunctionTemplate> alert_template =
425        v8::FunctionTemplate::New(&AlertCallback, v8_this_);
426    global_template->Set(ASCIILiteralToV8String("alert"), alert_template);
427
428    v8::Local<v8::FunctionTemplate> my_ip_address_template =
429        v8::FunctionTemplate::New(&MyIpAddressCallback, v8_this_);
430    global_template->Set(ASCIILiteralToV8String("myIpAddress"),
431        my_ip_address_template);
432
433    v8::Local<v8::FunctionTemplate> dns_resolve_template =
434        v8::FunctionTemplate::New(&DnsResolveCallback, v8_this_);
435    global_template->Set(ASCIILiteralToV8String("dnsResolve"),
436        dns_resolve_template);
437
438    // Microsoft's PAC extensions:
439
440    v8::Local<v8::FunctionTemplate> dns_resolve_ex_template =
441        v8::FunctionTemplate::New(&DnsResolveExCallback, v8_this_);
442    global_template->Set(ASCIILiteralToV8String("dnsResolveEx"),
443                         dns_resolve_ex_template);
444
445    v8::Local<v8::FunctionTemplate> my_ip_address_ex_template =
446        v8::FunctionTemplate::New(&MyIpAddressExCallback, v8_this_);
447    global_template->Set(ASCIILiteralToV8String("myIpAddressEx"),
448                         my_ip_address_ex_template);
449
450    v8::Local<v8::FunctionTemplate> sort_ip_address_list_template =
451        v8::FunctionTemplate::New(&SortIpAddressListCallback, v8_this_);
452    global_template->Set(ASCIILiteralToV8String("sortIpAddressList"),
453                         sort_ip_address_list_template);
454
455    v8::Local<v8::FunctionTemplate> is_in_net_ex_template =
456        v8::FunctionTemplate::New(&IsInNetExCallback, v8_this_);
457    global_template->Set(ASCIILiteralToV8String("isInNetEx"),
458                         is_in_net_ex_template);
459
460    v8_context_ = v8::Context::New(NULL, global_template);
461
462    v8::Context::Scope ctx(v8_context_);
463
464    // Add the PAC utility functions to the environment.
465    // (This script should never fail, as it is a string literal!)
466    // Note that the two string literals are concatenated.
467    int rv = RunScript(
468        ASCIILiteralToV8String(
469            PROXY_RESOLVER_SCRIPT
470            PROXY_RESOLVER_SCRIPT_EX),
471        kPacUtilityResourceName);
472    if (rv != OK) {
473      return rv;
474    }
475
476    // Add the user's PAC code to the environment.
477    rv = RunScript(UTF16StringToV8String(pac_script), kPacResourceName);
478    if (rv != OK) {
479      return rv;
480    }
481
482    // At a minimum, the FindProxyForURL() function must be defined for this
483    // to be a legitimiate PAC script.
484    v8::Local<v8::Value> function;
485    if (!GetFindProxyForURL(&function))
486      return ERR_PAC_SCRIPT_FAILED;
487
488    return OK;
489  }
490
491  void PurgeMemory() {
492    v8::Locker locked;
493    // Repeatedly call the V8 idle notification until it returns true ("nothing
494    // more to free").  Note that it makes more sense to do this than to
495    // implement a new "delete everything" pass because object references make
496    // it difficult to free everything possible in just one pass.
497    while (!v8::V8::IdleNotification())
498      ;
499  }
500
501 private:
502  bool GetFindProxyForURL(v8::Local<v8::Value>* function) {
503    *function = v8_context_->Global()->Get(
504        ASCIILiteralToV8String("FindProxyForURL"));
505    return (*function)->IsFunction();
506  }
507
508  // Handle an exception thrown by V8.
509  void HandleError(v8::Handle<v8::Message> message) {
510    if (message.IsEmpty())
511      return;
512    error_listener_->ErrorMessage(V8StringToUTF16(message->Get()));
513  }
514
515  // Compiles and runs |script| in the current V8 context.
516  // Returns OK on success, otherwise an error code.
517  int RunScript(v8::Handle<v8::String> script, const char* script_name) {
518    v8::TryCatch try_catch;
519
520    // Compile the script.
521    v8::ScriptOrigin origin =
522        v8::ScriptOrigin(ASCIILiteralToV8String(script_name));
523    v8::Local<v8::Script> code = v8::Script::Compile(script, &origin);
524
525    // Execute.
526    if (!code.IsEmpty())
527      code->Run();
528
529    // Check for errors.
530    if (try_catch.HasCaught()) {
531      HandleError(try_catch.Message());
532      return ERR_PAC_SCRIPT_FAILED;
533    }
534
535    return OK;
536  }
537
538  // V8 callback for when "alert()" is invoked by the PAC script.
539  static v8::Handle<v8::Value> AlertCallback(const v8::Arguments& args) {
540    Context* context =
541        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
542
543    // Like firefox we assume "undefined" if no argument was specified, and
544    // disregard any arguments beyond the first.
545    android::String16 message;
546    if (args.Length() == 0) {
547      std::string undef = "undefined";
548      android::String8 undef8(undef.c_str());
549      android::String16 wundef(undef8);
550      message = wundef;
551    } else {
552      if (!V8ObjectToUTF16String(args[0], &message))
553        return v8::Undefined();  // toString() threw an exception.
554    }
555
556    context->error_listener_->AlertMessage(message);
557    return v8::Undefined();
558  }
559
560  // V8 callback for when "myIpAddress()" is invoked by the PAC script.
561  static v8::Handle<v8::Value> MyIpAddressCallback(const v8::Arguments& args) {
562    Context* context =
563        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
564
565    std::string result;
566    bool success;
567
568    {
569      v8::Unlocker unlocker;
570
571      // We shouldn't be called with any arguments, but will not complain if
572      // we are.
573      success = context->js_bindings_->MyIpAddress(&result);
574    }
575
576    if (!success)
577      return ASCIILiteralToV8String("127.0.0.1");
578    return ASCIIStringToV8String(result);
579  }
580
581  // V8 callback for when "myIpAddressEx()" is invoked by the PAC script.
582  static v8::Handle<v8::Value> MyIpAddressExCallback(
583      const v8::Arguments& args) {
584    Context* context =
585        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
586
587    std::string ip_address_list;
588    bool success;
589
590    {
591      v8::Unlocker unlocker;
592
593      // We shouldn't be called with any arguments, but will not complain if
594      // we are.
595      success = context->js_bindings_->MyIpAddressEx(&ip_address_list);
596    }
597
598    if (!success)
599      ip_address_list = std::string();
600    return ASCIIStringToV8String(ip_address_list);
601  }
602
603  // V8 callback for when "dnsResolve()" is invoked by the PAC script.
604  static v8::Handle<v8::Value> DnsResolveCallback(const v8::Arguments& args) {
605    Context* context =
606        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
607
608    // We need at least one string argument.
609    std::string hostname;
610    if (!GetHostnameArgument(args, &hostname))
611      return v8::Null();
612
613    std::string ip_address;
614    bool success;
615
616    {
617      v8::Unlocker unlocker;
618      success = context->js_bindings_->DnsResolve(hostname, &ip_address);
619    }
620
621    return success ? ASCIIStringToV8String(ip_address) : v8::Null();
622  }
623
624  // V8 callback for when "dnsResolveEx()" is invoked by the PAC script.
625  static v8::Handle<v8::Value> DnsResolveExCallback(const v8::Arguments& args) {
626    Context* context =
627        static_cast<Context*>(v8::External::Cast(*args.Data())->Value());
628
629    // We need at least one string argument.
630    std::string hostname;
631    if (!GetHostnameArgument(args, &hostname))
632      return v8::Undefined();
633
634    std::string ip_address_list;
635    bool success;
636
637    {
638      v8::Unlocker unlocker;
639      success = context->js_bindings_->DnsResolveEx(hostname, &ip_address_list);
640    }
641
642    if (!success)
643      ip_address_list = std::string();
644
645    return ASCIIStringToV8String(ip_address_list);
646  }
647
648  // V8 callback for when "sortIpAddressList()" is invoked by the PAC script.
649  static v8::Handle<v8::Value> SortIpAddressListCallback(
650      const v8::Arguments& args) {
651    // We need at least one string argument.
652    if (args.Length() == 0 || args[0].IsEmpty() || !args[0]->IsString())
653      return v8::Null();
654
655    std::string ip_address_list = V8StringToUTF8(args[0]->ToString());
656    std::string sorted_ip_address_list;
657    bool success = SortIpAddressList(ip_address_list, &sorted_ip_address_list);
658    if (!success)
659      return v8::False();
660    return ASCIIStringToV8String(sorted_ip_address_list);
661  }
662
663  // V8 callback for when "isInNetEx()" is invoked by the PAC script.
664  static v8::Handle<v8::Value> IsInNetExCallback(const v8::Arguments& args) {
665    // We need at least 2 string arguments.
666    if (args.Length() < 2 || args[0].IsEmpty() || !args[0]->IsString() ||
667        args[1].IsEmpty() || !args[1]->IsString())
668      return v8::Null();
669
670    std::string ip_address = V8StringToUTF8(args[0]->ToString());
671    std::string ip_prefix = V8StringToUTF8(args[1]->ToString());
672    return IsInNetEx(ip_address, ip_prefix) ? v8::True() : v8::False();
673  }
674
675  ProxyResolverJSBindings* js_bindings_;
676  ProxyErrorListener* error_listener_;
677  v8::Persistent<v8::External> v8_this_;
678  v8::Persistent<v8::Context> v8_context_;
679};
680
681// ProxyResolverV8 ------------------------------------------------------------
682
683ProxyResolverV8::ProxyResolverV8(
684    ProxyResolverJSBindings* custom_js_bindings,
685    ProxyErrorListener* error_listener)
686    : context_(NULL), js_bindings_(custom_js_bindings),
687      error_listener_(error_listener) {
688
689}
690
691ProxyResolverV8::~ProxyResolverV8() {
692  if (context_ != NULL) {
693    delete context_;
694    context_ = NULL;
695  }
696  if (js_bindings_ != NULL) {
697    delete js_bindings_;
698  }
699}
700
701int ProxyResolverV8::GetProxyForURL(const android::String16 spec, const android::String16 host,
702                                    android::String16* results) {
703  // If the V8 instance has not been initialized (either because
704  // SetPacScript() wasn't called yet, or because it failed.
705  if (context_ == NULL)
706    return ERR_FAILED;
707
708  // Otherwise call into V8.
709  int rv = context_->ResolveProxy(spec, host, results);
710
711  return rv;
712}
713
714void ProxyResolverV8::PurgeMemory() {
715  context_->PurgeMemory();
716}
717
718int ProxyResolverV8::SetPacScript(android::String16& script_data) {
719  if (context_ != NULL) {
720    delete context_;
721    context_ = NULL;
722  }
723  if (script_data.size() == 0)
724    return ERR_PAC_SCRIPT_FAILED;
725
726  // Try parsing the PAC script.
727  context_ = new Context(js_bindings_, error_listener_);
728  int rv;
729  if ((rv = context_->InitV8(script_data)) != OK) {
730    context_ = NULL;
731  }
732  if (rv != OK)
733    context_ = NULL;
734  return rv;
735}
736
737}  // namespace net
738