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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.webkit;
import android.app.LoadedApk;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.os.AsyncTask;
import android.os.Build;
import android.os.ChildZygoteProcess;
import android.os.Process;
import android.os.ZygoteProcess;
import android.text.TextUtils;
import android.util.Log;
import com.android.internal.annotations.GuardedBy;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/** @hide */
public class WebViewZygote {
private static final String LOGTAG = "WebViewZygote";
/**
* Lock object that protects all other static members.
*/
private static final Object sLock = new Object();
/**
* Instance that maintains the socket connection to the zygote. This is {@code null} if the
* zygote is not running or is not connected.
*/
@GuardedBy("sLock")
private static ChildZygoteProcess sZygote;
/**
* Information about the selected WebView package. This is set from #onWebViewProviderChanged().
*/
@GuardedBy("sLock")
private static PackageInfo sPackage;
/**
* Original ApplicationInfo for the selected WebView package before stub fixup. This is set from
* #onWebViewProviderChanged().
*/
@GuardedBy("sLock")
private static ApplicationInfo sPackageOriginalAppInfo;
/**
* Flag for whether multi-process WebView is enabled. If this is {@code false}, the zygote
* will not be started.
*/
@GuardedBy("sLock")
private static boolean sMultiprocessEnabled = false;
public static ZygoteProcess getProcess() {
synchronized (sLock) {
if (sZygote != null) return sZygote;
connectToZygoteIfNeededLocked();
return sZygote;
}
}
public static String getPackageName() {
synchronized (sLock) {
return sPackage.packageName;
}
}
public static boolean isMultiprocessEnabled() {
synchronized (sLock) {
return sMultiprocessEnabled && sPackage != null;
}
}
public static void setMultiprocessEnabled(boolean enabled) {
synchronized (sLock) {
sMultiprocessEnabled = enabled;
// When toggling between multi-process being on/off, start or stop the
// zygote. If it is enabled and the zygote is not yet started, launch it.
// Otherwise, kill it. The name may be null if the package information has
// not yet been resolved.
if (enabled) {
// Run on a background thread as this waits for the zygote to start and we don't
// want to block the caller on this. It's okay if this is delayed as anyone trying
// to use the zygote will call it first anyway.
AsyncTask.THREAD_POOL_EXECUTOR.execute(WebViewZygote::getProcess);
} else {
// No need to run this in the background, it's very brief.
stopZygoteLocked();
}
}
}
public static void onWebViewProviderChanged(PackageInfo packageInfo,
ApplicationInfo originalAppInfo) {
synchronized (sLock) {
sPackage = packageInfo;
sPackageOriginalAppInfo = originalAppInfo;
// If multi-process is not enabled, then do not start the zygote service.
if (!sMultiprocessEnabled) {
return;
}
stopZygoteLocked();
}
}
@GuardedBy("sLock")
private static void stopZygoteLocked() {
if (sZygote != null) {
// Close the connection and kill the zygote process. This will not cause
// child processes to be killed by itself. But if this is called in response to
// setMultiprocessEnabled() or onWebViewProviderChanged(), the WebViewUpdater
// will kill all processes that depend on the WebView package.
sZygote.close();
Process.killProcess(sZygote.getPid());
sZygote = null;
}
}
@GuardedBy("sLock")
private static void connectToZygoteIfNeededLocked() {
if (sZygote != null) {
return;
}
if (sPackage == null) {
Log.e(LOGTAG, "Cannot connect to zygote, no package specified");
return;
}
try {
sZygote = Process.ZYGOTE_PROCESS.startChildZygote(
"com.android.internal.os.WebViewZygoteInit",
"webview_zygote",
Process.WEBVIEW_ZYGOTE_UID,
Process.WEBVIEW_ZYGOTE_UID,
null, // gids
0, // runtimeFlags
"webview_zygote", // seInfo
sPackage.applicationInfo.primaryCpuAbi, // abi
null); // instructionSet
// All the work below is usually done by LoadedApk, but the zygote can't talk to
// PackageManager or construct a LoadedApk since it's single-threaded pre-fork, so
// doesn't have an ActivityThread and can't use Binder.
// Instead, figure out the paths here, in the system server where we have access to
// the package manager. Reuse the logic from LoadedApk to determine the correct
// paths and pass them to the zygote as strings.
final List<String> zipPaths = new ArrayList<>(10);
final List<String> libPaths = new ArrayList<>(10);
LoadedApk.makePaths(null, false, sPackage.applicationInfo, zipPaths, libPaths);
final String librarySearchPath = TextUtils.join(File.pathSeparator, libPaths);
final String zip = (zipPaths.size() == 1) ? zipPaths.get(0) :
TextUtils.join(File.pathSeparator, zipPaths);
String libFileName = WebViewFactory.getWebViewLibrary(sPackage.applicationInfo);
// In the case where the ApplicationInfo has been modified by the stub WebView,
// we need to use the original ApplicationInfo to determine what the original classpath
// would have been to use as a cache key.
LoadedApk.makePaths(null, false, sPackageOriginalAppInfo, zipPaths, null);
final String cacheKey = (zipPaths.size() == 1) ? zipPaths.get(0) :
TextUtils.join(File.pathSeparator, zipPaths);
ZygoteProcess.waitForConnectionToZygote(sZygote.getPrimarySocketAddress());
Log.d(LOGTAG, "Preloading package " + zip + " " + librarySearchPath);
sZygote.preloadPackageForAbi(zip, librarySearchPath, libFileName, cacheKey,
Build.SUPPORTED_ABIS[0]);
} catch (Exception e) {
Log.e(LOGTAG, "Error connecting to webview zygote", e);
stopZygoteLocked();
}
}
}
|
