1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// 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.
#ifndef NET_PROXY_PROXY_RESOLVER_V8_H_
#define NET_PROXY_PROXY_RESOLVER_V8_H_
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "net/base/net_export.h"
#include "net/proxy/proxy_resolver.h"
namespace v8 {
class HeapStatistics;
class Isolate;
} // namespace v8
namespace net {
// Implementation of ProxyResolver that uses V8 to evaluate PAC scripts.
//
// ----------------------------------------------------------------------------
// !!! Important note on threading model:
// ----------------------------------------------------------------------------
// There can be only one instance of V8 running at a time. To enforce this
// constraint, ProxyResolverV8 holds a v8::Locker during execution. Therefore
// it is OK to run multiple instances of ProxyResolverV8 on different threads,
// since only one will be running inside V8 at a time.
//
// It is important that *ALL* instances of V8 in the process be using
// v8::Locker. If not there can be race conditions between the non-locked V8
// instances and the locked V8 instances used by ProxyResolverV8 (assuming they
// run on different threads).
//
// This is the case with the V8 instance used by chromium's renderer -- it runs
// on a different thread from ProxyResolver (renderer thread vs PAC thread),
// and does not use locking since it expects to be alone.
class NET_EXPORT_PRIVATE ProxyResolverV8 : public ProxyResolver {
public:
// Interface for the javascript bindings.
class NET_EXPORT_PRIVATE JSBindings {
public:
enum ResolveDnsOperation {
DNS_RESOLVE,
DNS_RESOLVE_EX,
MY_IP_ADDRESS,
MY_IP_ADDRESS_EX,
};
JSBindings() {}
// Handler for "dnsResolve()", "dnsResolveEx()", "myIpAddress()",
// "myIpAddressEx()". Returns true on success and fills |*output| with the
// result. If |*terminate| is set to true, then the script execution will
// be aborted. Note that termination may not happen right away.
virtual bool ResolveDns(const std::string& host,
ResolveDnsOperation op,
std::string* output,
bool* terminate) = 0;
// Handler for "alert(message)"
virtual void Alert(const base::string16& message) = 0;
// Handler for when an error is encountered. |line_number| may be -1
// if a line number is not applicable to this error.
virtual void OnError(int line_number, const base::string16& error) = 0;
protected:
virtual ~JSBindings() {}
};
// Constructs a ProxyResolverV8.
ProxyResolverV8();
virtual ~ProxyResolverV8();
JSBindings* js_bindings() const { return js_bindings_; }
void set_js_bindings(JSBindings* js_bindings) { js_bindings_ = js_bindings; }
// ProxyResolver implementation:
virtual int GetProxyForURL(const GURL& url,
ProxyInfo* results,
const net::CompletionCallback& /*callback*/,
RequestHandle* /*request*/,
const BoundNetLog& net_log) OVERRIDE;
virtual void CancelRequest(RequestHandle request) OVERRIDE;
virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
virtual void CancelSetPacScript() OVERRIDE;
virtual void PurgeMemory() OVERRIDE;
virtual int SetPacScript(
const scoped_refptr<ProxyResolverScriptData>& script_data,
const net::CompletionCallback& /*callback*/) OVERRIDE;
// Remember the default Isolate, must be called from the main thread. This
// hack can be removed when the "default Isolate" concept is gone.
static void RememberDefaultIsolate();
#if defined(OS_WIN)
// Create an isolate to use for the proxy resolver. Until the "default
// Isolate" concept is gone, it is preferable to invoke
// RememberDefaultIsolate() as creating a new Isolate in additional to the
// default Isolate will waste a few MB of memory and the runtime it took to
// create the default Isolate.
static void CreateIsolate();
#endif
static v8::Isolate* GetDefaultIsolate();
// Get total/ued heap memory usage of all v8 instances used by the proxy
// resolver.
static size_t GetTotalHeapSize();
static size_t GetUsedHeapSize();
private:
static v8::Isolate* g_default_isolate_;
// Context holds the Javascript state for the most recently loaded PAC
// script. It corresponds with the data from the last call to
// SetPacScript().
class Context;
scoped_ptr<Context> context_;
JSBindings* js_bindings_;
DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8);
};
} // namespace net
#endif // NET_PROXY_PROXY_RESOLVER_V8_H_
|
