Clean up DocumentWriter creation's FrameLoader interaction

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
  * Copyright (C) 2011 Kris Jordan <krisjordan@gmail.com>
  * Copyright (C) 2011 Google Inc. All rights reserved.
@@ skipping 42 matching lines @@
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
-#include "core/html/parser/HTMLParserIdioms.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
-#include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FormSubmission.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/LinkLoader.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/loader/NavigationScheduler.h"
 #include "core/loader/NetworkHintsInterface.h"
 #include "core/loader/ProgressTracker.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
-#include "core/origin_trials/OriginTrialContext.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/CreateWindow.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/WindowFeatures.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "core/xml/parser/XMLDocumentParser.h"
 #include "platform/InstanceCounters.h"
 #include "platform/PluginScriptForbiddenScope.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/UserGestureIndicator.h"
-#include "platform/feature_policy/FeaturePolicy.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/scroll/ScrollAnimatorBase.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "platform/weborigin/Suborigin.h"
 #include "public/platform/WebCachePolicy.h"
-#include "public/platform/WebFeaturePolicy.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "wtf/AutoReset.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 using blink::WebURLRequest;
 
 namespace blink {
 
@@ skipping 355 matching lines @@
       return InitialCommitInChildFrame;
     case FrameLoadTypeBackForward:
       return BackForwardCommit;
     default:
       break;
   }
   return HistoryInertCommit;
 }
 
 void FrameLoader::receivedFirstData() {
-  if (m_stateMachine.creatingInitialEmptyDocument())
-    return;
-
   FrameLoadType loadType = m_documentLoader->loadType();
   HistoryCommitType historyCommitType = loadTypeToCommitType(loadType);
   if (historyCommitType == StandardCommit &&
       (m_documentLoader->urlForHistory().isEmpty() ||
        (opener() && !m_currentItem &&
         m_documentLoader->originalRequest().url().isEmpty())))
     historyCommitType = HistoryInertCommit;
   setHistoryItemStateForCommit(loadType, historyCommitType,
                                HistoryNavigationType::DifferentDocument);
 
   if (!m_stateMachine.committedMultipleRealLoads() &&
       loadType == FrameLoadTypeStandard) {
     m_stateMachine.advanceTo(
         FrameLoaderStateMachine::CommittedMultipleRealLoads);
   }
 
   client()->dispatchDidCommitLoad(m_currentItem.get(), historyCommitType);
 
   // When the embedder gets notified (above) that the new navigation has
   // committed, the embedder will drop the old Content Security Policy and
   // therefore now is a good time to report to the embedder the Content Security
   // Policies that have accumulated so far for the new navigation.
   m_frame->securityContext()->contentSecurityPolicy()->reportAccumulatedHeaders(
       client());
-
-  // didObserveLoadingBehavior() must be called after dispatchDidCommitLoad() is
-  // called for the metrics tracking logic to handle it properly.
-  if (m_documentLoader->getServiceWorkerNetworkProvider() &&
-      m_documentLoader->getServiceWorkerNetworkProvider()
-          ->isControlledByServiceWorker()) {
-    client()->didObserveLoadingBehavior(
-        WebLoadingBehaviorServiceWorkerControlled);
-  }
-
-  // Links with media values need more information (like viewport information).
-  // This happens after the first chunk is parsed in HTMLDocumentParser.
-  m_documentLoader->dispatchLinkHeaderPreloads(nullptr,
-                                               LinkLoader::OnlyLoadNonMedia);
-
-  TRACE_EVENT1("devtools.timeline", "CommitLoad", "data",
-               InspectorCommitLoadEvent::data(m_frame));
-  probe::didCommitLoad(m_frame, m_documentLoader.get());
-  m_frame->page()->didCommitLoad(m_frame);
-  dispatchDidClearDocumentOfWindowObject();
-
-  takeObjectSnapshot();
 }
 
-void FrameLoader::didInstallNewDocument(bool dispatchWindowObjectAvailable) {
-  DCHECK(m_frame);
-  DCHECK(m_frame->document());
-
-  m_frame->document()->setReadyState(Document::Loading);
-
-  if (dispatchWindowObjectAvailable)
-    dispatchDidClearDocumentOfWindowObject();
-
-  m_frame->document()->initContentSecurityPolicy(
-      m_documentLoader ? m_documentLoader->releaseContentSecurityPolicy()
-                       : ContentSecurityPolicy::create());
-
+void FrameLoader::didInstallNewDocument() {
   if (m_provisionalItem &&
       isBackForwardLoadType(m_documentLoader->loadType())) {
     m_frame->document()->setStateForNewFormElements(
         m_provisionalItem->getDocumentState());
   }
 }
 
-void FrameLoader::didBeginDocument() {
-  DCHECK(m_frame);
-  DCHECK(m_frame->client());
-  DCHECK(m_frame->document());
-  DCHECK(m_frame->document()->fetcher());
-
-  if (m_documentLoader) {
-    String suboriginHeader =
-        m_documentLoader->response().httpHeaderField(HTTPNames::Suborigin);
-    if (!suboriginHeader.isNull()) {
-      Vector<String> messages;
-      Suborigin suborigin;
-      if (parseSuboriginHeader(suboriginHeader, &suborigin, messages))
-        m_frame->document()->enforceSuborigin(suborigin);
-
-      for (auto& message : messages) {
-        m_frame->document()->addConsoleMessage(
-            ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel,
-                                   "Error with Suborigin header: " + message));
-      }
-    }
-    m_frame->document()->clientHintsPreferences().updateFrom(
-        m_documentLoader->clientHintsPreferences());
-  }
-
-  Settings* settings = m_frame->document()->settings();
-  if (settings) {
-    m_frame->document()->fetcher()->setImagesEnabled(
-        settings->getImagesEnabled());
-    m_frame->document()->fetcher()->setAutoLoadImages(
-        settings->getLoadsImagesAutomatically());
-  }
-
-  if (m_documentLoader) {
-    const AtomicString& dnsPrefetchControl =
-        m_documentLoader->response().httpHeaderField(
-            HTTPNames::X_DNS_Prefetch_Control);
-    if (!dnsPrefetchControl.isEmpty())
-      m_frame->document()->parseDNSPrefetchControlHeader(dnsPrefetchControl);
-
-    String headerContentLanguage = m_documentLoader->response().httpHeaderField(
-        HTTPNames::Content_Language);
-    if (!headerContentLanguage.isEmpty()) {
-      size_t commaIndex = headerContentLanguage.find(',');
-      headerContentLanguage.truncate(
-          commaIndex);  // kNotFound == -1 == don't truncate
-      headerContentLanguage =
-          headerContentLanguage.stripWhiteSpace(isHTMLSpace<UChar>);
-      if (!headerContentLanguage.isEmpty()) {
-        m_frame->document()->setContentLanguage(
-            AtomicString(headerContentLanguage));
-      }
-    }
-
-    OriginTrialContext::addTokensFromHeader(
-        m_frame->document(),
-        m_documentLoader->response().httpHeaderField(HTTPNames::Origin_Trial));
-    if (RuntimeEnabledFeatures::featurePolicyEnabled()) {
-      WebFeaturePolicy* parentFeaturePolicy =
-          (isLoadingMainFrame() ? nullptr
-                                : m_frame->client()
-                                      ->parent()
-                                      ->securityContext()
-                                      ->getFeaturePolicy());
-      const String& featurePolicyHeader =
-          m_documentLoader->response().httpHeaderField(
-              HTTPNames::Feature_Policy);
-      Vector<String> messages;
-      const WebParsedFeaturePolicy& parsedHeader = parseFeaturePolicy(
-          featurePolicyHeader, m_frame->securityContext()->getSecurityOrigin(),
-          &messages);
-      WebParsedFeaturePolicy containerPolicy;
-      if (m_frame->owner()) {
-        containerPolicy = getContainerPolicyFromAllowedFeatures(
-            m_frame->owner()->allowedFeatures(),
-            m_frame->securityContext()->getSecurityOrigin());
-      }
-      m_frame->securityContext()->initializeFeaturePolicy(
-          parsedHeader, containerPolicy, parentFeaturePolicy);
-      for (auto& message : messages) {
-        m_frame->document()->addConsoleMessage(ConsoleMessage::create(
-            OtherMessageSource, ErrorMessageLevel,
-            "Error with Feature-Policy header: " + message));
-      }
-      if (!parsedHeader.isEmpty())
-        client()->didSetFeaturePolicyHeader(parsedHeader);
-    }
-  }
-
-  if (m_documentLoader) {
-    String referrerPolicyHeader = m_documentLoader->response().httpHeaderField(
-        HTTPNames::Referrer_Policy);
-    if (!referrerPolicyHeader.isNull()) {
-      UseCounter::count(*m_frame->document(), UseCounter::ReferrerPolicyHeader);
-      m_frame->document()->parseAndSetReferrerPolicy(referrerPolicyHeader);
-    }
-  }
-
-  client()->didCreateNewDocument();
-}
-
 void FrameLoader::finishedParsing() {
   if (m_stateMachine.creatingInitialEmptyDocument())
     return;
 
   m_progressTracker->finishedParsing();
 
   if (client()) {
     ScriptForbiddenScope forbidScripts;
     client()->dispatchDidFinishDocumentLoad();
   }
@@ skipping 1211 matching lines @@
   client()->documentElementAvailable();
 }
 
 void FrameLoader::runScriptsAtDocumentElementAvailable() {
   client()->runScriptsAtDocumentElementAvailable();
   // The frame might be detached at this point.
 }
 
 void FrameLoader::dispatchDidClearDocumentOfWindowObject() {
   DCHECK(m_frame->document());
+  if (m_stateMachine.creatingInitialEmptyDocument())
+    return;
   if (!m_frame->document()->canExecuteScripts(NotAboutToExecuteScript))
     return;
 
   Settings* settings = m_frame->settings();
   if (settings && settings->getForceMainWorldInitialization()) {
     // Forcibly instantiate WindowProxy.
     m_frame->script().windowProxy(DOMWrapperWorld::mainWorld());
   }
   probe::didClearDocumentOfWindowObject(m_frame);
 
@@ skipping 153 matching lines @@
       frameLoadRequest.clientRedirect());
 
   loader->setLoadType(loadType);
   loader->setNavigationType(navigationType);
   loader->setReplacesCurrentHistoryItem(loadType ==
                                         FrameLoadTypeReplaceCurrentItem);
   return loader;
 }
 
 }  // namespace blink