src/third_party/WebKit/Source/core/loader/DocumentLoader.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2011 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1.  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  * 2.  Redistributions in binary form must reproduce the above copyright
  12  *     notice, this list of conditions and the following disclaimer in the
  13  *     documentation and/or other materials provided with the distribution.
  14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  15  *     its contributors may be used to endorse or promote products derived
  16  *     from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "config.h"
  31 #include "core/loader/DocumentLoader.h"
  32
  33 #include "core/FetchInitiatorTypeNames.h"
  34 #include "core/dom/Document.h"
  35 #include "core/dom/DocumentParser.h"
  36 #include "core/events/Event.h"
  37 #include "core/fetch/MemoryCache.h"
  38 #include "core/fetch/ResourceFetcher.h"
  39 #include "core/fetch/ResourceLoader.h"
  40 #include "core/frame/LocalDOMWindow.h"
  41 #include "core/frame/LocalFrame.h"
  42 #include "core/frame/csp/ContentSecurityPolicy.h"
  43 #include "core/html/HTMLFrameOwnerElement.h"
  44 #include "core/html/parser/TextResourceDecoder.h"
  45 #include "core/inspector/InspectorInstrumentation.h"
  46 #include "core/loader/FrameLoader.h"
  47 #include "core/loader/FrameLoaderClient.h"
  48 #include "core/loader/UniqueIdentifier.h"
  49 #include "core/loader/appcache/ApplicationCacheHost.h"
  50 #include "core/page/FrameTree.h"
  51 #include "core/page/Page.h"
  52 #include "core/frame/Settings.h"
  53 #include "core/inspector/ConsoleMessage.h"
  54 #include "platform/Logging.h"
  55 #include "platform/UserGestureIndicator.h"
  56 #include "platform/mhtml/ArchiveResource.h"
  57 #include "platform/mhtml/ArchiveResourceCollection.h"
  58 #include "platform/mhtml/MHTMLArchive.h"
  59 #include "platform/network/ContentSecurityPolicyResponseHeaders.h"
  60 #include "platform/plugins/PluginData.h"
  61 #include "platform/weborigin/SchemeRegistry.h"
  62 #include "platform/weborigin/SecurityPolicy.h"
  63 #include "public/platform/Platform.h"
  64 #include "public/platform/WebMimeRegistry.h"
  65 #include "public/platform/WebThreadedDataReceiver.h"
  66 #include "wtf/Assertions.h"
  67 #include "wtf/text/WTFString.h"
  68
  69 namespace blink {
  70
  71 static bool isArchiveMIMEType(const String& mimeType)
  72 {
  73     return mimeType == "multipart/related";
  74 }
  75
  76 DocumentLoader::DocumentLoader(LocalFrame* frame, const ResourceRequest& req, const SubstituteData& substituteData)
  77     : m_frame(frame)
  78     , m_fetcher(ResourceFetcher::create(this))
  79     , m_originalRequest(req)
  80     , m_substituteData(substituteData)
  81     , m_request(req)
  82     , m_committed(false)
  83     , m_isClientRedirect(false)
  84     , m_replacesCurrentHistoryItem(false)
  85     , m_loadingMainResource(false)
  86     , m_timeOfLastDataReceived(0.0)
  87     , m_applicationCacheHost(ApplicationCacheHost::create(this))
  88 {
  89 }
  90
  91 FrameLoader* DocumentLoader::frameLoader() const
  92 {
  93     if (!m_frame)
  94         return 0;
  95     return &m_frame->loader();
  96 }
  97
  98 ResourceLoader* DocumentLoader::mainResourceLoader() const
  99 {
 100     return m_mainResource ? m_mainResource->loader() : 0;
 101 }
 102
 103 DocumentLoader::~DocumentLoader()
 104 {
 105     ASSERT(!m_frame || !isLoading());
 106     m_fetcher->clearDocumentLoader();
 107     clearMainResourceHandle();
 108     m_applicationCacheHost->dispose();
 109 }
 110
 111 unsigned long DocumentLoader::mainResourceIdentifier() const
 112 {
 113     return m_mainResource ? m_mainResource->identifier() : 0;
 114 }
 115
 116 Document* DocumentLoader::document() const
 117 {
 118     if (m_frame && m_frame->loader().documentLoader() == this)
 119         return m_frame->document();
 120     return 0;
 121 }
 122
 123 const ResourceRequest& DocumentLoader::originalRequest() const
 124 {
 125     return m_originalRequest;
 126 }
 127
 128 const ResourceRequest& DocumentLoader::request() const
 129 {
 130     return m_request;
 131 }
 132
 133 const KURL& DocumentLoader::url() const
 134 {
 135     return m_request.url();
 136 }
 137
 138 void DocumentLoader::updateForSameDocumentNavigation(const KURL& newURL, SameDocumentNavigationSource sameDocumentNavigationSource)
 139 {
 140     KURL oldURL = m_request.url();
 141     m_originalRequest.setURL(newURL);
 142     m_request.setURL(newURL);
 143     if (sameDocumentNavigationSource == SameDocumentNavigationHistoryApi) {
 144         m_request.setHTTPMethod("GET");
 145         m_request.setHTTPBody(nullptr);
 146     }
 147     clearRedirectChain();
 148     if (m_isClientRedirect)
 149         appendRedirect(oldURL);
 150     appendRedirect(newURL);
 151 }
 152
 153 const KURL& DocumentLoader::urlForHistory() const
 154 {
 155     return unreachableURL().isEmpty() ? url() : unreachableURL();
 156 }
 157
 158 void DocumentLoader::setMainDocumentError(const ResourceError& error)
 159 {
 160     m_mainDocumentError = error;
 161 }
 162
 163 void DocumentLoader::mainReceivedError(const ResourceError& error)
 164 {
 165     ASSERT(!error.isNull());
 166     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
 167     m_applicationCacheHost->failedLoadingMainResource();
 168     if (!frameLoader())
 169         return;
 170     setMainDocumentError(error);
 171     clearMainResourceLoader();
 172     frameLoader()->receivedMainResourceError(error);
 173     clearMainResourceHandle();
 174 }
 175
 176 // Cancels the data source's pending loads.  Conceptually, a data source only loads
 177 // one document at a time, but one document may have many related resources.
 178 // stopLoading will stop all loads initiated by the data source,
 179 // but not loads initiated by child frames' data sources -- that's the WebFrame's job.
 180 void DocumentLoader::stopLoading()
 181 {
 182     RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
 183     RefPtr<DocumentLoader> protectLoader(this);
 184
 185     // In some rare cases, calling FrameLoader::stopLoading could cause isLoading() to return false.
 186     // (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it
 187     // to stop loading. Because of this, we need to save it so we don't return early.
 188     bool loading = isLoading();
 189
 190     if (m_committed) {
 191         // Attempt to stop the frame if the document loader is loading, or if it is done loading but
 192         // still  parsing. Failure to do so can cause a world leak.
 193         Document* doc = m_frame->document();
 194
 195         if (loading || doc->parsing())
 196             m_frame->loader().stopLoading();
 197     }
 198
 199     if (!loading) {
 200         m_fetcher->stopFetching();
 201         return;
 202     }
 203
 204     if (m_loadingMainResource) {
 205         // Stop the main resource loader and let it send the cancelled message.
 206         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 207     } else if (m_fetcher->isFetching()) {
 208         // The main resource loader already finished loading. Set the cancelled error on the
 209         // document and let the resourceLoaders send individual cancelled messages below.
 210         setMainDocumentError(ResourceError::cancelledError(m_request.url()));
 211     } else {
 212         // If there are no resource loaders, we need to manufacture a cancelled message.
 213         // (A back/forward navigation has no resource loaders because its resources are cached.)
 214         mainReceivedError(ResourceError::cancelledError(m_request.url()));
 215     }
 216
 217     m_fetcher->stopFetching();
 218 }
 219
 220 void DocumentLoader::commitIfReady()
 221 {
 222     if (!m_committed) {
 223         m_committed = true;
 224         frameLoader()->commitProvisionalLoad();
 225     }
 226 }
 227
 228 bool DocumentLoader::isLoading() const
 229 {
 230     if (document() && document()->hasActiveParser())
 231         return true;
 232
 233     return m_loadingMainResource || m_fetcher->isFetching();
 234 }
 235
 236 void DocumentLoader::notifyFinished(Resource* resource)
 237 {
 238     ASSERT_UNUSED(resource, m_mainResource == resource);
 239     ASSERT(m_mainResource);
 240
 241     RefPtr<DocumentLoader> protect(this);
 242
 243     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
 244         finishedLoading(m_mainResource->loadFinishTime());
 245         return;
 246     }
 247
 248     mainReceivedError(m_mainResource->resourceError());
 249 }
 250
 251 void DocumentLoader::finishedLoading(double finishTime)
 252 {
 253     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
 254
 255     RefPtr<DocumentLoader> protect(this);
 256
 257     double responseEndTime = finishTime;
 258     if (!responseEndTime)
 259         responseEndTime = m_timeOfLastDataReceived;
 260     if (!responseEndTime)
 261         responseEndTime = monotonicallyIncreasingTime();
 262     timing()->setResponseEnd(responseEndTime);
 263
 264     commitIfReady();
 265     if (!frameLoader())
 266         return;
 267
 268     if (!maybeCreateArchive()) {
 269         // If this is an empty document, it will not have actually been created yet. Commit dummy data so that
 270         // DocumentWriter::begin() gets called and creates the Document.
 271         if (!m_writer)
 272             commitData(0, 0);
 273     }
 274
 275     endWriting(m_writer.get());
 276
 277     if (!m_mainDocumentError.isNull())
 278         return;
 279     clearMainResourceLoader();
 280     if (!frameLoader()->stateMachine()->creatingInitialEmptyDocument())
 281         frameLoader()->checkLoadComplete();
 282
 283     // If the document specified an application cache manifest, it violates the author's intent if we store it in the memory cache
 284     // and deny the appcache the chance to intercept it in the future, so remove from the memory cache.
 285     if (m_frame) {
 286         if (m_mainResource && m_frame->document()->hasAppCacheManifest())
 287             memoryCache()->remove(m_mainResource.get());
 288     }
 289     m_applicationCacheHost->finishedLoadingMainResource();
 290     clearMainResourceHandle();
 291 }
 292
 293 bool DocumentLoader::isRedirectAfterPost(const ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 294 {
 295     int status = redirectResponse.httpStatusCode();
 296     if (((status >= 301 && status <= 303) || status == 307)
 297         && m_originalRequest.httpMethod() == "POST")
 298         return true;
 299
 300     return false;
 301 }
 302
 303 bool DocumentLoader::shouldContinueForNavigationPolicy(const ResourceRequest& request, ContentSecurityPolicyCheck shouldCheckMainWorldContentSecurityPolicy, bool isTransitionNavigation)
 304 {
 305     // Don't ask if we are loading an empty URL.
 306     if (request.url().isEmpty() || m_substituteData.isValid())
 307         return true;
 308
 309     // If we're loading content into a subframe, check against the parent's Content Security Policy
 310     // and kill the load if that check fails, unless we should bypass the main world's CSP.
 311     // FIXME: CSP checks are broken for OOPI. For now, this policy always allows frames with a remote parent...
 312     if ((shouldCheckMainWorldContentSecurityPolicy == CheckContentSecurityPolicy) && (m_frame->deprecatedLocalOwner() && !m_frame->deprecatedLocalOwner()->document().contentSecurityPolicy()->allowChildFrameFromSource(request.url()))) {
 313         // Fire a load event, as timing attacks would otherwise reveal that the
 314         // frame was blocked. This way, it looks like every other cross-origin
 315         // page load.
 316         m_frame->document()->enforceSandboxFlags(SandboxOrigin);
 317         m_frame->owner()->dispatchLoad();
 318         return false;
 319     }
 320
 321     NavigationPolicy policy = m_triggeringAction.policy();
 322     policy = frameLoader()->client()->decidePolicyForNavigation(request, this, policy, isTransitionNavigation);
 323     if (policy == NavigationPolicyCurrentTab)
 324         return true;
 325     if (policy == NavigationPolicyIgnore)
 326         return false;
 327     if (!LocalDOMWindow::allowPopUp(*m_frame) && !UserGestureIndicator::processingUserGesture())
 328         return false;
 329     frameLoader()->client()->loadURLExternally(request, policy);
 330     return false;
 331 }
 332
 333 void DocumentLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
 334 {
 335     ASSERT_UNUSED(resource, resource == m_mainResource);
 336     willSendRequest(request, redirectResponse);
 337 }
 338
 339 void DocumentLoader::updateRequest(Resource* resource, const ResourceRequest& request)
 340 {
 341     ASSERT_UNUSED(resource, resource == m_mainResource);
 342     m_request = request;
 343 }
 344
 345 static bool isFormSubmission(NavigationType type)
 346 {
 347     return type == NavigationTypeFormSubmitted || type == NavigationTypeFormResubmitted;
 348 }
 349
 350 void DocumentLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 351 {
 352     // Note that there are no asserts here as there are for the other callbacks. This is due to the
 353     // fact that this "callback" is sent when starting every load, and the state of callback
 354     // deferrals plays less of a part in this function in preventing the bad behavior deferring
 355     // callbacks is meant to prevent.
 356     ASSERT(!newRequest.isNull());
 357     if (isFormSubmission(m_triggeringAction.type()) && !m_frame->document()->contentSecurityPolicy()->allowFormAction(newRequest.url())) {
 358         cancelMainResourceLoad(ResourceError::cancelledError(newRequest.url()));
 359         return;
 360     }
 361
 362     ASSERT(timing()->fetchStart());
 363     if (!redirectResponse.isNull()) {
 364         // If the redirecting url is not allowed to display content from the target origin,
 365         // then block the redirect.
 366         RefPtr<SecurityOrigin> redirectingOrigin = SecurityOrigin::create(redirectResponse.url());
 367         if (!redirectingOrigin->canDisplay(newRequest.url())) {
 368             FrameLoader::reportLocalLoadFailed(m_frame, newRequest.url().string());
 369             cancelMainResourceLoad(ResourceError::cancelledError(newRequest.url()));
 370             return;
 371         }
 372         timing()->addRedirect(redirectResponse.url(), newRequest.url());
 373     }
 374
 375     // If we're fielding a redirect in response to a POST, force a load from origin, since
 376     // this is a common site technique to return to a page viewing some data that the POST
 377     // just modified.
 378     if (newRequest.cachePolicy() == UseProtocolCachePolicy && isRedirectAfterPost(newRequest, redirectResponse))
 379         newRequest.setCachePolicy(ReloadBypassingCache);
 380
 381     m_request = newRequest;
 382
 383     if (redirectResponse.isNull())
 384         return;
 385
 386     appendRedirect(newRequest.url());
 387     frameLoader()->client()->dispatchDidReceiveServerRedirectForProvisionalLoad();
 388     if (!shouldContinueForNavigationPolicy(newRequest, CheckContentSecurityPolicy))
 389         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 390 }
 391
 392 static bool canShowMIMEType(const String& mimeType, Page* page)
 393 {
 394     if (blink::Platform::current()->mimeRegistry()->supportsMIMEType(mimeType) == blink::WebMimeRegistry::IsSupported)
 395         return true;
 396     PluginData* pluginData = page->pluginData();
 397     return !mimeType.isEmpty() && pluginData && pluginData->supportsMimeType(mimeType);
 398 }
 399
 400 bool DocumentLoader::shouldContinueForResponse() const
 401 {
 402     if (m_substituteData.isValid())
 403         return true;
 404
 405     int statusCode = m_response.httpStatusCode();
 406     if (statusCode == 204 || statusCode == 205) {
 407         // The server does not want us to replace the page contents.
 408         return false;
 409     }
 410
 411     if (contentDispositionType(m_response.httpHeaderField("Content-Disposition")) == ContentDispositionAttachment) {
 412         // The server wants us to download instead of replacing the page contents.
 413         // Downloading is handled by the embedder, but we still get the initial
 414         // response so that we can ignore it and clean up properly.
 415         return false;
 416     }
 417
 418     if (!canShowMIMEType(m_response.mimeType(), m_frame->page()))
 419         return false;
 420
 421     // Prevent remote web archives from loading because they can claim to be from any domain and thus avoid cross-domain security checks.
 422     if (equalIgnoringCase("multipart/related", m_response.mimeType()) && !SchemeRegistry::shouldTreatURLSchemeAsLocal(m_request.url().protocol()))
 423         return false;
 424
 425     return true;
 426 }
 427
 428 void DocumentLoader::cancelLoadAfterXFrameOptionsOrCSPDenied(const ResourceResponse& response)
 429 {
 430     InspectorInstrumentation::continueAfterXFrameOptionsDenied(m_frame, this, mainResourceIdentifier(), response);
 431
 432     frame()->document()->enforceSandboxFlags(SandboxOrigin);
 433     if (FrameOwner* owner = frame()->owner())
 434         owner->dispatchLoad();
 435
 436     // The load event might have detached this frame. In that case, the load will already have been cancelled during detach.
 437     if (frameLoader())
 438         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 439     return;
 440 }
 441
 442 void DocumentLoader::responseReceived(Resource* resource, const ResourceResponse& response)
 443 {
 444     ASSERT_UNUSED(resource, m_mainResource == resource);
 445     RefPtr<DocumentLoader> protect(this);
 446
 447     m_applicationCacheHost->didReceiveResponseForMainResource(response);
 448
 449     // The memory cache doesn't understand the application cache or its caching rules. So if a main resource is served
 450     // from the application cache, ensure we don't save the result for future use. All responses loaded
 451     // from appcache will have a non-zero appCacheID().
 452     if (response.appCacheID())
 453         memoryCache()->remove(m_mainResource.get());
 454
 455     DEFINE_STATIC_LOCAL(AtomicString, xFrameOptionHeader, ("x-frame-options", AtomicString::ConstructFromLiteral));
 456     HTTPHeaderMap::const_iterator it = response.httpHeaderFields().find(xFrameOptionHeader);
 457     if (it != response.httpHeaderFields().end()) {
 458         String content = it->value;
 459         if (frameLoader()->shouldInterruptLoadForXFrameOptions(content, response.url(), mainResourceIdentifier())) {
 460             String message = "Refused to display '" + response.url().elidedString() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
 461             RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, message);
 462             consoleMessage->setRequestIdentifier(mainResourceIdentifier());
 463             frame()->document()->addConsoleMessage(consoleMessage.release());
 464
 465             cancelLoadAfterXFrameOptionsOrCSPDenied(response);
 466             return;
 467         }
 468     }
 469
 470     m_contentSecurityPolicy = ContentSecurityPolicy::create();
 471     m_contentSecurityPolicy->setOverrideURLForSelf(response.url());
 472     m_contentSecurityPolicy->didReceiveHeaders(ContentSecurityPolicyResponseHeaders(response));
 473     if (!m_contentSecurityPolicy->allowAncestors(m_frame, response.url())) {
 474         cancelLoadAfterXFrameOptionsOrCSPDenied(response);
 475         return;
 476     }
 477
 478     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 479
 480     m_response = response;
 481
 482     if (isArchiveMIMEType(m_response.mimeType()) && m_mainResource->dataBufferingPolicy() != BufferData)
 483         m_mainResource->setDataBufferingPolicy(BufferData);
 484
 485     if (!shouldContinueForResponse()) {
 486         InspectorInstrumentation::continueWithPolicyIgnore(m_frame, this, m_mainResource->identifier(), m_response);
 487         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 488         return;
 489     }
 490
 491     if (m_response.isHTTP()) {
 492         int status = m_response.httpStatusCode();
 493         // FIXME: Fallback content only works if the parent is in the same processs.
 494         if ((status < 200 || status >= 300) && m_frame->owner()) {
 495             if (!m_frame->deprecatedLocalOwner()) {
 496                 ASSERT_NOT_REACHED();
 497             } else if (m_frame->deprecatedLocalOwner()->isObjectElement()) {
 498                 m_frame->deprecatedLocalOwner()->renderFallbackContent();
 499                 // object elements are no longer rendered after we fallback, so don't
 500                 // keep trying to process data from their load
 501                 cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 502             }
 503         }
 504     }
 505 }
 506
 507 void DocumentLoader::ensureWriter(const AtomicString& mimeType, const KURL& overridingURL)
 508 {
 509     if (m_writer)
 510         return;
 511
 512     const AtomicString& encoding = overrideEncoding().isNull() ? response().textEncodingName() : overrideEncoding();
 513
 514     // Prepare a DocumentInit before clearing the frame, because it may need to
 515     // inherit an aliased security context.
 516     DocumentInit init(url(), m_frame);
 517     init.withNewRegistrationContext();
 518     m_frame->loader().clear();
 519     ASSERT(m_frame->page());
 520
 521     m_writer = createWriterFor(0, init, mimeType, encoding, false);
 522     m_writer->setDocumentWasLoadedAsPartOfNavigation();
 523     // This should be set before receivedFirstData().
 524     if (!overridingURL.isEmpty())
 525         m_frame->document()->setBaseURLOverride(overridingURL);
 526
 527     // Call receivedFirstData() exactly once per load.
 528     frameLoader()->receivedFirstData();
 529     m_frame->document()->maybeHandleHttpRefresh(m_response.httpHeaderField("Refresh"), Document::HttpRefreshFromHeader);
 530 }
 531
 532 void DocumentLoader::commitData(const char* bytes, size_t length)
 533 {
 534     ensureWriter(m_response.mimeType());
 535     ASSERT(m_frame->document()->parsing());
 536     m_writer->addData(bytes, length);
 537 }
 538
 539 void DocumentLoader::dataReceived(Resource* resource, const char* data, int length)
 540 {
 541     ASSERT(data);
 542     ASSERT(length);
 543     ASSERT_UNUSED(resource, resource == m_mainResource);
 544     ASSERT(!m_response.isNull());
 545     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 546
 547     // Both unloading the old page and parsing the new page may execute JavaScript which destroys the datasource
 548     // by starting a new load, so retain temporarily.
 549     RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
 550     RefPtr<DocumentLoader> protectLoader(this);
 551
 552     m_applicationCacheHost->mainResourceDataReceived(data, length);
 553     m_timeOfLastDataReceived = monotonicallyIncreasingTime();
 554
 555     commitIfReady();
 556     if (!frameLoader())
 557         return;
 558     if (isArchiveMIMEType(response().mimeType()))
 559         return;
 560     commitData(data, length);
 561
 562     // If we are sending data to MediaDocument, we should stop here
 563     // and cancel the request.
 564     if (m_frame && m_frame->document()->isMediaDocument())
 565         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 566 }
 567
 568 void DocumentLoader::clearRedirectChain()
 569 {
 570     m_redirectChain.clear();
 571 }
 572
 573 void DocumentLoader::appendRedirect(const KURL& url)
 574 {
 575     m_redirectChain.append(url);
 576 }
 577
 578 void DocumentLoader::detachFromFrame()
 579 {
 580     ASSERT(m_frame);
 581     RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame);
 582     RefPtr<DocumentLoader> protectLoader(this);
 583
 584     // It never makes sense to have a document loader that is detached from its
 585     // frame have any loads active, so go ahead and kill all the loads.
 586     stopLoading();
 587
 588     m_applicationCacheHost->setApplicationCache(0);
 589     InspectorInstrumentation::loaderDetachedFromFrame(m_frame, this);
 590     m_frame = 0;
 591 }
 592
 593 void DocumentLoader::clearMainResourceLoader()
 594 {
 595     m_loadingMainResource = false;
 596 }
 597
 598 void DocumentLoader::clearMainResourceHandle()
 599 {
 600     if (!m_mainResource)
 601         return;
 602     m_mainResource->removeClient(this);
 603     m_mainResource = 0;
 604 }
 605
 606 bool DocumentLoader::maybeCreateArchive()
 607 {
 608     // Only the top-frame can load MHTML.
 609     if (m_frame->tree().parent())
 610         return false;
 611
 612     // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
 613     if (!isArchiveMIMEType(m_response.mimeType()))
 614         return false;
 615
 616     ASSERT(m_mainResource);
 617     m_archive = MHTMLArchive::create(m_response.url(), m_mainResource->resourceBuffer());
 618     // Invalid MHTML.
 619     if (!m_archive || !m_archive->mainResource()) {
 620         m_archive.clear();
 621         return false;
 622     }
 623
 624     addAllArchiveResources(m_archive.get());
 625     ArchiveResource* mainResource = m_archive->mainResource();
 626
 627     // The origin is the MHTML file, we need to set the base URL to the document encoded in the MHTML so
 628     // relative URLs are resolved properly.
 629     ensureWriter(mainResource->mimeType(), m_archive->mainResource()->url());
 630
 631     // The Document has now been created.
 632     document()->enforceSandboxFlags(SandboxAll);
 633
 634     commitData(mainResource->data()->data(), mainResource->data()->size());
 635     return true;
 636 }
 637
 638 void DocumentLoader::addAllArchiveResources(MHTMLArchive* archive)
 639 {
 640     ASSERT(archive);
 641     if (!m_archiveResourceCollection)
 642         m_archiveResourceCollection = ArchiveResourceCollection::create();
 643     m_archiveResourceCollection->addAllResources(archive);
 644 }
 645
 646 void DocumentLoader::prepareSubframeArchiveLoadIfNeeded()
 647 {
 648     if (!m_frame->tree().parent() || !m_frame->tree().parent()->isLocalFrame())
 649         return;
 650
 651     ArchiveResourceCollection* parentCollection = toLocalFrame(m_frame->tree().parent())->loader().documentLoader()->m_archiveResourceCollection.get();
 652     if (!parentCollection)
 653         return;
 654
 655     m_archive = parentCollection->popSubframeArchive(m_frame->tree().uniqueName(), m_request.url());
 656
 657     if (!m_archive)
 658         return;
 659     addAllArchiveResources(m_archive.get());
 660
 661     ArchiveResource* mainResource = m_archive->mainResource();
 662     m_substituteData = SubstituteData(mainResource->data(), mainResource->mimeType(), mainResource->textEncoding(), KURL());
 663 }
 664
 665 bool DocumentLoader::scheduleArchiveLoad(Resource* cachedResource, const ResourceRequest& request)
 666 {
 667     if (!m_archive)
 668         return false;
 669
 670     ASSERT(m_archiveResourceCollection);
 671     ArchiveResource* archiveResource = m_archiveResourceCollection->archiveResourceForURL(request.url());
 672     if (!archiveResource) {
 673         cachedResource->error(Resource::LoadError);
 674         return true;
 675     }
 676
 677     cachedResource->setLoading(true);
 678     cachedResource->responseReceived(archiveResource->response());
 679     SharedBuffer* data = archiveResource->data();
 680     if (data)
 681         cachedResource->appendData(data->data(), data->size());
 682     cachedResource->finish();
 683     return true;
 684 }
 685
 686 const AtomicString& DocumentLoader::responseMIMEType() const
 687 {
 688     return m_response.mimeType();
 689 }
 690
 691 const KURL& DocumentLoader::unreachableURL() const
 692 {
 693     return m_substituteData.failingURL();
 694 }
 695
 696 void DocumentLoader::setDefersLoading(bool defers)
 697 {
 698     // Multiple frames may be loading the same main resource simultaneously. If deferral state changes,
 699     // each frame's DocumentLoader will try to send a setDefersLoading() to the same underlying ResourceLoader. Ensure only
 700     // the "owning" DocumentLoader does so, as setDefersLoading() is not resilient to setting the same value repeatedly.
 701     if (mainResourceLoader() && mainResourceLoader()->isLoadedBy(m_fetcher.get()))
 702         mainResourceLoader()->setDefersLoading(defers);
 703
 704     m_fetcher->setDefersLoading(defers);
 705 }
 706
 707 bool DocumentLoader::maybeLoadEmpty()
 708 {
 709     bool shouldLoadEmpty = !m_substituteData.isValid() && (m_request.url().isEmpty() || SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(m_request.url().protocol()));
 710     if (!shouldLoadEmpty)
 711         return false;
 712
 713     if (m_request.url().isEmpty() && !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
 714         m_request.setURL(blankURL());
 715     m_response = ResourceResponse(m_request.url(), "text/html", 0, nullAtom, String());
 716     finishedLoading(monotonicallyIncreasingTime());
 717     return true;
 718 }
 719
 720 void DocumentLoader::startLoadingMainResource()
 721 {
 722     RefPtr<DocumentLoader> protect(this);
 723     m_mainDocumentError = ResourceError();
 724     timing()->markNavigationStart();
 725     ASSERT(!m_mainResource);
 726     ASSERT(!m_loadingMainResource);
 727     m_loadingMainResource = true;
 728
 729     if (maybeLoadEmpty())
 730         return;
 731
 732     ASSERT(timing()->navigationStart());
 733     ASSERT(!timing()->fetchStart());
 734     timing()->markFetchStart();
 735     willSendRequest(m_request, ResourceResponse());
 736
 737     // willSendRequest() may lead to our LocalFrame being detached or cancelling the load via nulling the ResourceRequest.
 738     if (!m_frame || m_request.isNull())
 739         return;
 740
 741     m_applicationCacheHost->willStartLoadingMainResource(m_request);
 742     prepareSubframeArchiveLoadIfNeeded();
 743
 744     ResourceRequest request(m_request);
 745     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, mainResourceLoadOptions,
 746         (DoNotBufferData, AllowStoredCredentials, ClientRequestedCredentials, CheckContentSecurityPolicy, DocumentContext));
 747     FetchRequest cachedResourceRequest(request, FetchInitiatorTypeNames::document, mainResourceLoadOptions);
 748     m_mainResource = m_fetcher->fetchMainResource(cachedResourceRequest, m_substituteData);
 749     if (!m_mainResource) {
 750         m_request = ResourceRequest();
 751         // If the load was aborted by clearing m_request, it's possible the ApplicationCacheHost
 752         // is now in a state where starting an empty load will be inconsistent. Replace it with
 753         // a new ApplicationCacheHost.
 754         m_applicationCacheHost = ApplicationCacheHost::create(this);
 755         maybeLoadEmpty();
 756         return;
 757     }
 758     m_mainResource->addClient(this);
 759
 760     // A bunch of headers are set when the underlying ResourceLoader is created, and m_request needs to include those.
 761     if (mainResourceLoader())
 762         request = mainResourceLoader()->originalRequest();
 763     // If there was a fragment identifier on m_request, the cache will have stripped it. m_request should include
 764     // the fragment identifier, so add that back in.
 765     if (equalIgnoringFragmentIdentifier(m_request.url(), request.url()))
 766         request.setURL(m_request.url());
 767     m_request = request;
 768 }
 769
 770 void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError)
 771 {
 772     RefPtr<DocumentLoader> protect(this);
 773     ResourceError error = resourceError.isNull() ? ResourceError::cancelledError(m_request.url()) : resourceError;
 774
 775     if (mainResourceLoader())
 776         mainResourceLoader()->cancel(error);
 777
 778     mainReceivedError(error);
 779 }
 780
 781 void DocumentLoader::attachThreadedDataReceiver(PassOwnPtr<blink::WebThreadedDataReceiver> threadedDataReceiver)
 782 {
 783     if (mainResourceLoader())
 784         mainResourceLoader()->attachThreadedDataReceiver(threadedDataReceiver);
 785 }
 786
 787 void DocumentLoader::endWriting(DocumentWriter* writer)
 788 {
 789     ASSERT_UNUSED(writer, m_writer == writer);
 790     m_writer->end();
 791     m_writer.clear();
 792 }
 793
 794 PassRefPtrWillBeRawPtr<DocumentWriter> DocumentLoader::createWriterFor(const Document* ownerDocument, const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch)
 795 {
 796     LocalFrame* frame = init.frame();
 797
 798     if (frame->document())
 799         frame->document()->prepareForDestruction();
 800
 801     if (!init.shouldReuseDefaultView())
 802         frame->setDOMWindow(LocalDOMWindow::create(*frame));
 803
 804     RefPtrWillBeRawPtr<Document> document = frame->domWindow()->installNewDocument(mimeType, init);
 805     if (ownerDocument) {
 806         document->setCookieURL(ownerDocument->cookieURL());
 807         document->setSecurityOrigin(ownerDocument->securityOrigin());
 808         if (ownerDocument->isTransitionDocument())
 809             document->setIsTransitionDocument();
 810     }
 811
 812     frame->loader().didBeginDocument(dispatch);
 813
 814     return DocumentWriter::create(document.get(), mimeType, encoding);
 815 }
 816
 817 const AtomicString& DocumentLoader::mimeType() const
 818 {
 819     if (m_writer)
 820         return m_writer->mimeType();
 821     return m_response.mimeType();
 822 }
 823
 824 void DocumentLoader::setUserChosenEncoding(const String& charset)
 825 {
 826     if (m_writer)
 827         m_writer->setUserChosenEncoding(charset);
 828 }
 829
 830 // This is only called by FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
 831 void DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit& init, const String& source, Document* ownerDocument)
 832 {
 833     m_writer = createWriterFor(ownerDocument, init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true);
 834     if (!source.isNull())
 835         m_writer->appendReplacingData(source);
 836     endWriting(m_writer.get());
 837 }
 838
 839 } // namespace blink