Android WebKit HTML主资源加载过程
前言
在浏览器里面输入网址，最终浏览器会调用WebView的loadUrl()，然后就开始加载整个网页。整个加载过程中，最重要的一步就是HTML主资源的加载。WebKit将网页的资源分为主资源(MainResource)和子资源(SubResource)。
WebKit资源分类
主资源：HTML文件。
子资源：CSS, JS, JPG等等，除了HTML文件之外的所有资源都称之为子资源
本章主要讲主资源的加载过程，子资源的加载过程后期会专门详细的分析和讲解。
主资源请求
LoadUrl
主资源的请求是从WebView的loadUrl开始的。根据之前《Android WebKit消息处理》的讲解，WebView的操作都会有WebViewClassic进行代理。资源加载肯定是由WebCore来处理的，所以，WebVewClassic会发消息给WebViewCore，让WebViewCore最终将loadUrl传递给C++层的WebKit处理：
/**
* See {@link WebView#loadUrl(String, Map)}
*/
@Override
public void loadUrl(String url, Map<String, String> additionalHttpHeaders) {
loadUrlImpl(url, additionalHttpHeaders);
}
private void loadUrlImpl(String url, Map<String, String> extraHeaders) {
switchOutDrawHistory();
WebViewCore.GetUrlData arg = new WebViewCore.GetUrlData();
arg.mUrl = url;
arg.mExtraHeaders = extraHeaders;
mWebViewCore.sendMessage(EventHub.LOAD_URL, arg);
clearHelpers();
}
WebViewCore在接收到LOAD_URL之后，会通过BrowserFrame调用nativeLoadUrl，这个BrowserFrame与C++层的mainFrame对接。这里顺便提一下clearHeapers()的作用：如果当前网页有对话框dialog，有输入法之类的，clearHelpers就是用来清理这些东西的。这也是为什么加载一个新页面的时候，但当前页面的输入法以及dialog消失等等。WebViewCore收到消息之后，会直接让BrowserFrame调用JNI: nativeLoadUrl():
// BrowserFrame.java
public void loadUrl(String url, Map<String, String> extraHeaders) {
mLoadInitFromJava = true;
if (URLUtil.isJavaScriptUrl(url)) {
// strip off the scheme and evaluate the string
stringByEvaluatingJavaScriptFromString(
url.substring("javascript:".length()));
} else {
/** M: add log */
Xlog.d(XLOGTAG, "browser frame loadUrl: " + url);
nativeLoadUrl(url, extraHeaders);
}
mLoadInitFromJava = false;
}由于LoadUrl()不仅可以Load一个url，还可以执行一段js。如果load的是一段js，js并没有被继续往下load，而是直接在这里执行掉。stringByEvaluatingJavaScriptFromString也会通过jni调用v8的接口去在mainFrame的scriptController中执行，关于js在WebKit后期会专门写一篇关于WebKit的js的文章进行专门分析。到目前为止，LoadUrl还只是简单的使用一个String传递字符串而已。
// WebCoreFrameBridge.cpp
static void LoadUrl(JNIEnv *env, jobject obj, jstring url, jobject headers)
{
WebCore::Frame* pFrame = GET_NATIVE_FRAME(env, obj);
ALOG_ASSERT(pFrame, "nativeLoadUrl must take a valid frame pointer!");
WTF::String webcoreUrl = jstringToWtfString(env, url);
WebCore::KURL kurl(WebCore::KURL(), webcoreUrl);
WebCore::ResourceRequest request(kurl);
if (headers) {
// dalvikvm will raise exception if any of these fail
jclass mapClass = env->FindClass("java/util/Map");
jmethodID entrySet = env->GetMethodID(mapClass, "entrySet",
"()Ljava/util/Set;");
jobject set = env->CallObjectMethod(headers, entrySet);
jclass setClass = env->FindClass("java/util/Set");
jmethodID iterator = env->GetMethodID(setClass, "iterator",
"()Ljava/util/Iterator;");
jobject iter = env->CallObjectMethod(set, iterator);
jclass iteratorClass = env->FindClass("java/util/Iterator");
jmethodID hasNext = env->GetMethodID(iteratorClass, "hasNext", "()Z");
jmethodID next = env->GetMethodID(iteratorClass, "next",
"()Ljava/lang/Object;");
jclass entryClass = env->FindClass("java/util/Map$Entry");
jmethodID getKey = env->GetMethodID(entryClass, "getKey",
"()Ljava/lang/Object;");
jmethodID getValue = env->GetMethodID(entryClass, "getValue",
"()Ljava/lang/Object;");
while (env->CallBooleanMethod(iter, hasNext)) {
jobject entry = env->CallObjectMethod(iter, next);
jstring key = (jstring) env->CallObjectMethod(entry, getKey);
jstring value = (jstring) env->CallObjectMethod(entry, getValue);
request.setHTTPHeaderField(jstringToWtfString(env, key), jstringToWtfString(env, value));
env->DeleteLocalRef(entry);
env->DeleteLocalRef(key);
env->DeleteLocalRef(value);
}
// ...
pFrame->loader()->load(request, false);
}
接下来，在JNI的LoadUrl中就开始创建ResourceRequest，由于WebView的java层面可以对url的请求头进行设定，然后通过FrameLoader进行加载。这里的pFrame就是与Java层的BrowserFrame对应的mainFrame。HTML在WebKit的层次上看，最低层的是Frame，然后才有Document，也就意味着HTML Document也是通过Frame的FrameLoader加载的：
pFrame->loader()->load(request, false);
调用栈
最后的这句话就是让FrameLoader去加载url的request。后面的调用栈依次是：void FrameLoader::load(const ResourceRequest& request, bool lockHistory)
void FrameLoader::load(const ResourceRequest& request, const SubstituteData& substituteData, bool lockHistory)
void FrameLoader::load(DocumentLoader* newDocumentLoader)
void FrameLoader::loadWithDocumentLoader(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> prpFormState)
void FrameLoader::callContinueLoadAfterNavigationPolicy(void* argument,
const ResourceRequest& request, PassRefPtr<FormState> formState, bool shouldContinue)
void FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState> formState, bool shouldContinue)
void FrameLoader::continueLoadAfterWillSubmitForm()其中加载Document的DocumentLoader在load中创建的：
void FrameLoader::load(const ResourceRequest& request, const SubstituteData& substituteData, bool lockHistory)
{
if (m_inStopAllLoaders)
return;
// FIXME: is this the right place to reset loadType? Perhaps this should be done after loading is finished or aborted.
m_loadType = FrameLoadTypeStandard;
RefPtr<DocumentLoader> loader = m_client->createDocumentLoader(request, substituteData);
if (lockHistory && m_documentLoader)
loader->setClientRedirectSourceForHistory(m_documentLoader->didCreateGlobalHistoryEntry() ? m_documentLoader->urlForHistory().string() : m_documentLoader->clientRedirectSourceForHistory());
load(loader.get());
}m_client->createDocumentLoader(request, substituteData);中的m_client是FrameLoaderClientAndroid。后面资源下载还有跟这个m_client打交道。在void FrameLoader::continueLoadAfterWillSubmitForm()之前，还没有真正涉及到主资源的加载，还都只是在对当前需要加载的Url进行一些列的判断，一方面是安全问题，SecurityOrigin会对Url进行安全检查，例如跨域。另一方面是Scroll，因为有时候后LoadUrl加载的Url会带有Url Fragment也就是hash。关于url的hash的内容请参考
《Fragment URLS》由于URL的hash，只会滚动到页面的某一个位置，所以这种情况下也不需要真正的去请求mainResource. 如果这些检查都过了，就需要开始去加载mainResource了：
// FrameLoader.cpp
void FrameLoader::continueLoadAfterWillSubmitForm()
{
// ...
m_provisionalDocumentLoader->timing()->navigationStart = currentTime();
// ...
if (!m_provisionalDocumentLoader->startLoadingMainResource(identifier))
m_provisionalDocumentLoader->updateLoading();
}startLoadingMainResource这就开始load主资源也就是前面说的html文件。
三种DocumentLoader
这里需要对m_provisionalDocumentLoader进行讲解下：
RefPtr<DocumentLoader> m_documentLoader;
RefPtr<DocumentLoader> m_provisionalDocumentLoader;
RefPtr<DocumentLoader> m_policyDocumentLoader;
void setDocumentLoader(DocumentLoader*);
void setPolicyDocumentLoader(DocumentLoader*);
void setProvisionalDocumentLoader(DocumentLoader*);我们可以看到在FrameLoader.h中定义了三个DocumentLoader，WebKit其实是按角色划分这几个DocumentLoader的。其中：m_documentLoader是上一次已经加载过的DocumentLoader的指针，m_policyDocumentLoader就是用来做一些策略性的工作的，例如延迟加载等等。m_provisionalDocumentLoade是用来做实际的加载工作的。当一个DocumentLoader的工作完成之后，会通过setXXXXDocumentLoader来传递指针。按照URL加载的主流程：PolicyChcek------>Load MainResouce。也就是先进行策略检查，最后才开始加载主资源。那么这个三个DocumentLoader的顺序应该是先createDocumentLoader后的指针传递给m_pollicyDocumentLoader，在策略检查完之后，将指针传递给m_provisionalDocumentLoader，在Document加载完毕之后，将指针传递给m_documentLoader。
// FrameLoader.cpp
void FrameLoader::loadWithDocumentLoader(DocumentLoader* loader, FrameLoadType type, PassRefPtr<FormState> prpFormState)
{
// ...
policyChecker()->stopCheck();
// ...
setPolicyDocumentLoader(loader);
// ..
}
void FrameLoader::continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState> formState, bool shouldContinue)
{
// ...
setProvisionalDocumentLoader(m_policyDocumentLoader.get());
m_loadType = type;
setState(FrameStateProvisional);
// ...
setPolicyDocumentLoader(0);
}
void FrameLoader::transitionToCommitted(PassRefPtr<CachedPage> cachedPage)
{
// ...
setDocumentLoader(m_provisionalDocumentLoader.get());
setProvisionalDocumentLoader(0);
// ...
}
void FrameLoader::checkLoadCompleteForThisFrame()
{
switch (m_state) {
case FrameStateProvisional: {
// ...
// If we're in the middle of loading multipart data, we need to restore the document loader.
if (isReplacing() && !m_documentLoader.get())
setDocumentLoader(m_provisionalDocumentLoader.get());
// Finish resetting the load state, but only if another load hasn't been started by the
// delegate callback.
if (pdl == m_provisionalDocumentLoader)
clearProvisionalLoad();
}
// ...
}上面代码片段可以看出，这三个DocumentLoader的承接关系是一环扣一环。由于index.html加载在WebKit中分为2中方式：如果是前进后退，index.html是从CachedPage中加载的，FrameLoader::transitionToCommitted就是在从CachedPage中加载完成之后被调用的，void FrameLoader::checkLoadCompleteForThisFrame()这是在从网络加载完成之后被调用的。
// FrameLoader.cpp
void FrameLoader::recursiveCheckLoadComplete()
{
Vector<RefPtr<Frame>, 10> frames;
for (RefPtr<Frame> frame = m_frame->tree()->firstChild(); frame; frame = frame->tree()->nextSibling())
frames.append(frame);
unsigned size = frames.size();
for (unsigned i = 0; i < size; i++)
frames[i]->loader()->recursiveCheckLoadComplete();
checkLoadCompleteForThisFrame();
}
// Called every time a resource is completely loaded, or an error is received.
void FrameLoader::checkLoadComplete()
{
ASSERT(m_client->hasWebView());
m_shouldCallCheckLoadComplete = false;
// FIXME: Always traversing the entire frame tree is a bit inefficient, but
// is currently needed in order to null out the previous history item for all frames.
if (Page* page = m_frame->page())
page->mainFrame()->loader()->recursiveCheckLoadComplete();
}需要强调的是，WebKit需要对Page里面的所有Frame进行确认加载完毕之后，最后将setDocumentLoader()。对于这一点我个人理解是还有优化的空间。
startLoadingMainResource
在m_provisionalDocumentLoader调用startLoadingMainResource之后，就开始准备发送网络请求了。调用栈如下：bool DocumentLoader::startLoadingMainResource(unsigned long identifier)
bool MainResourceLoader::load(const ResourceRequest& r, const SubstituteData& substituteData)
bool MainResourceLoader::loadNow(ResourceRequest& r)
PassRefPtr<ResourceHandle> ResourceHandle::create(NetworkingContext* context,
const ResourceRequest& request,
ResourceHandleClient* client,
bool defersLoading,
bool shouldContentSniff)
bool ResourceHandle::start(NetworkingContext* context)
PassRefPtr<ResourceLoaderAndroid> ResourceLoaderAndroid::start(
ResourceHandle* handle, const ResourceRequest& request,
FrameLoaderClient* client, bool isMainResource, bool isSync)
bool WebUrlLoaderClient::start(bool isMainResource, bool isMainFrame, bool sync, WebRequestContext* context)需要指出的是，虽然LoadUrl最后是在WebCore线程中执行的，但是最后资源下载是在Chromium_net的IO线程中进行的。在资源下载完毕之后，网络数据会交给FrameLoaderClientAndroid
网络数据
Android WebKit数据下载在Chromium_net的IO线程中完成之后会通过WebUrlLoaderClient向WebCore提交数据。WebKt的调用栈如下：
// Finish
void WebUrlLoaderClient::didFinishLoading()
void ResourceLoader::didFinishLoading(ResourceHandle*, double finishTime)
void MainResourceLoader::didFinishLoading(double finishTime)
void FrameLoader::finishedLoading()
void DocumentLoader::finishedLoading()
void FrameLoader::finishedLoadingDocument(DocumentLoader* loader)
void FrameLoaderClientAndroid::finishedLoading(DocumentLoader* docLoader)
void FrameLoaderClientAndroid::committedLoad(DocumentLoader* loader,
const char* data, int length)
void DocumentLoader::commitData(const char* bytes, int length)
// Receive Data
void WebUrlLoaderClient::didReceiveData(scoped_refptr<net::IOBuffer> buf, int size)
void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, int length,
int encodedDataLength)
void ResourceLoader::didReceiveData(const char* data, int length,
long long encodedDataLength, bool allAtOnce)
void MainResourceLoader::addData(const char* data, int length, bool allAtOnce)
void DocumentLoader::receivedData(const char* data, int length)
void DocumentLoader::commitLoad(const char* data, int length)
void FrameLoaderClientAndroid::committedLoad(DocumentLoader* loader,
const char* data, int length)
void DocumentLoader::commitData(const char* bytes, int length)
这个过程其实分为两步，一步是Chromium_net收到数据，另一部是Chromium_net通知WebKit，数据已经下载完毕可以finish了。这个两个过程都会调用FrameLoaderClienetAndroid::committedLoad()。只不过参数不一样，在finish的时候，将传入的length为0，这样通知WebKit，数据已经传送完毕，记者WebKit就开始使用commitData拿到的数据进行解析，构建Dom Tree和Render Tree。关于Dom Tree Render Tree的构建过程下一节详细的讲述。
版权申明：
转载文章请注明原文出处，任何用于商业目的，请联系谭海燕本人：hyman_tan@126.com
