Always send a fail or finish notification for each navigation.

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

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 113 matching lines @@
 FrameLoader* DocumentLoader::frameLoader() const {
   if (!m_frame)
     return nullptr;
   return &m_frame->loader();
 }
 
 DocumentLoader::~DocumentLoader() {
   DCHECK(!m_frame);
   DCHECK(!m_mainResource);
   DCHECK(!m_applicationCacheHost);
+  DCHECK_EQ(m_state, SentDidFinishLoad);
 }
 
 DEFINE_TRACE(DocumentLoader) {
   visitor->trace(m_frame);
   visitor->trace(m_fetcher);
   visitor->trace(m_mainResource);
   visitor->trace(m_writer);
   visitor->trace(m_documentLoadTiming);
   visitor->trace(m_applicationCacheHost);
   visitor->trace(m_contentSecurityPolicy);
@@ skipping 129 matching lines @@
   DCHECK_EQ(m_mainResource, resource);
   DCHECK(m_mainResource);
 
   if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
     finishedLoading(m_mainResource->loadFinishTime());
     return;
   }
 
   if (m_applicationCacheHost)
     m_applicationCacheHost->failedLoadingMainResource();
-  m_state = MainResourceDone;
   frameLoader()->loadFailed(this, m_mainResource->resourceError());
   clearMainResourceHandle();
 }
 
 void DocumentLoader::finishedLoading(double finishTime) {
   DCHECK(m_frame->loader().stateMachine()->creatingInitialEmptyDocument() ||
          !m_frame->page()->suspended() ||
          InspectorInstrumentation::isDebuggerPaused(m_frame));
 
   double responseEndTime = finishTime;
@@ skipping 13 matching lines @@
     // the Document.
     if (!m_writer)
       commitData(0, 0);
   }
 
   if (!m_frame)
     return;
 
   m_applicationCacheHost->finishedLoadingMainResource();
   endWriting();
-  if (m_state < MainResourceDone)
-    m_state = MainResourceDone;
   clearMainResourceHandle();
 }
 
 bool DocumentLoader::redirectReceived(
     Resource* resource,
     const ResourceRequest& request,
     const ResourceResponse& redirectResponse) {
   DCHECK_EQ(resource, m_mainResource);
   DCHECK(!redirectResponse.isNull());
   m_request = request;
@@ skipping 214 matching lines @@
 
   m_writer = createWriterFor(init, mimeType, encoding, false, parsingPolicy,
                              overridingURL);
   m_writer->setDocumentWasLoadedAsPartOfNavigation();
   m_frame->document()->maybeHandleHttpRefresh(
       m_response.httpHeaderField(HTTPNames::Refresh),
       Document::HttpRefreshFromHeader);
 }
 
 void DocumentLoader::commitData(const char* bytes, size_t length) {
-  DCHECK_LT(m_state, MainResourceDone);
+  DCHECK_EQ(m_state, Committed);
   ensureWriter(m_response.mimeType());
 
   // This can happen if document.close() is called by an event handler while
   // there's still pending incoming data.
   if (m_frame && !m_frame->document()->parsing())
     return;
 
   if (length)
     m_dataReceived = true;
 
@@ skipping 61 matching lines @@
   m_redirectChain.append(url);
 }
 
 void DocumentLoader::detachFromFrame() {
   DCHECK(m_frame);
 
   // It never makes sense to have a document loader that is detached from its
   // frame have any loads active, so go ahead and kill all the loads.
   m_fetcher->stopFetching();
 
+  if (frameLoader() && !sentDidFinishLoad())
+    frameLoader()->loadFailed(this, ResourceError::cancelledError(url()));

[Nate Chapin, 2016/12/12 21:40:37]

This feels a little hacky, but it ensures we always send a didFail(). I don't
see a great alternative to it.

[gsennton, 2016/12/13 13:59:55]

I'm not sure I understand when we should receive a didFinishLoad and when we
should receive a didFailLoad.
Today we receive didFinishLoad for loads where the request fails but we do
receive some content from the server (and here you suggest posting didFailLoad
if the request fails but the response contains no data?). OnPageFinished is only
posted if we receive didFinishLoad (and in some specific cases of didFailLoad -
namely if we end up with the error NetError.ERR_ABORTED).

Should the behaviour between failing requests with, and without content (we
still receive a response, it just contains no data) from the server actually
differ?

+
   // If that load cancellation triggered another detach, leave.
   // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
   if (!m_frame)
     return;
 
   m_fetcher->clearContext();
   m_applicationCacheHost->detachFromDocumentLoader();
   m_applicationCacheHost.clear();
   WeakIdentifierMap<DocumentLoader>::notifyObjectDestroyed(this);
   clearMainResourceHandle();
@@ skipping 156 matching lines @@
                              m_writer ? m_writer->encoding() : emptyAtom, true,
                              ForceSynchronousParsing);
   if (!source.isNull())
     m_writer->appendReplacingData(source);
   endWriting();
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 }  // namespace blink