Make SecurityContextInit a standalone class in its own file

Bug: 1029822
Change-Id: I87a379cde39641431a0099ffd8bb982128c51a74
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2001738
Commit-Queue: Nate Chapin <japhet@chromium.org>
Commit-Queue: Kentaro Hara <haraken@chromium.org>
Auto-Submit: Nate Chapin <japhet@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#731783}

third_party/blink/renderer/core/dom/document.h

@@ -178,6 +178,7 @@ class ScriptPromise;
 class ScriptRunner;
 class ScriptableDocumentParser;
 class ScriptedAnimationController;
+class SecurityContextInit;
 class SecurityOrigin;
 class SelectorQueryCache;
 class SerializedScriptValue;
@@ -1499,7 +1500,9 @@ class CORE_EXPORT Document : public ContainerNode,
   LazyLoadImageObserver& EnsureLazyLoadImageObserver();
 
   WindowAgent& GetWindowAgent();
-  WindowAgentFactory* GetWindowAgentFactory() { return window_agent_factory_; }
+  WindowAgentFactory* GetWindowAgentFactory() const {
+    return window_agent_factory_;
+  }
 
   void CountPotentialFeaturePolicyViolation(
       mojom::FeaturePolicyFeature) const override;
@@ -1650,7 +1653,6 @@ class CORE_EXPORT Document : public ContainerNode,
   FRIEND_TEST_ALL_PREFIXES(FrameFetchContextSubresourceFilterTest,
                            DuringOnFreeze);
   class NetworkStateObserver;
-  class SecurityContextInit;
 
   Document(const DocumentInit& initization,
            SecurityContextInit init_helper,

third_party/blink/renderer/core/execution_context/BUILD.gn

@@ -22,6 +22,8 @@ blink_core_sources("execution_context") {
     "remote_security_context.h",
     "security_context.cc",
     "security_context.h",
+    "security_context_init.cc",
+    "security_context_init.h",
     "window_agent.cc",
     "window_agent.h",
     "window_agent_factory.cc",

third_party/blink/renderer/core/execution_context/security_context_init.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_EXECUTION_CONTEXT_SECURITY_CONTEXT_INIT_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_EXECUTION_CONTEXT_SECURITY_CONTEXT_INIT_H_
+
+#include "third_party/blink/public/common/feature_policy/feature_policy.h"
+#include "third_party/blink/public/mojom/feature_policy/feature_policy_feature.mojom-blink.h"
+#include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/core/feature_policy/feature_policy_parser_delegate.h"
+#include "third_party/blink/renderer/core/frame/web_feature.h"
+#include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/wtf/hash_set.h"
+#include "third_party/blink/renderer/platform/wtf/vector.h"
+
+namespace blink {
+class Agent;
+class ContentSecurityPolicy;
+class Document;
+class DocumentInit;
+class OriginTrialContext;
+class SecurityOrigin;
+class SecurityOrigin;
+enum class WebSandboxFlags;
+class WindowAgentFactory;
+
+using DocumentClassFlags = unsigned char;
+
+class SecurityContextInit : public FeaturePolicyParserDelegate {
+  STACK_ALLOCATED();
+
+ public:
+  explicit SecurityContextInit(const DocumentInit&, DocumentClassFlags);
+
+  const scoped_refptr<SecurityOrigin>& GetSecurityOrigin() const {
+    return security_origin_;
+  }
+
+  WebSandboxFlags GetSandboxFlags() { return sandbox_flags_; }
+
+  ContentSecurityPolicy* GetCSP() const { return csp_; }
+
+  std::unique_ptr<FeaturePolicy> TakeFeaturePolicy() {
+    DCHECK(feature_policy_);
+    return std::move(feature_policy_);
+  }
+
+  std::unique_ptr<DocumentPolicy> TakeDocumentPolicy() {
+    DCHECK(document_policy_);
+    return std::move(document_policy_);
+  }
+
+  const Vector<String>& FeaturePolicyParseMessages() const {
+    return feature_policy_parse_messages_;
+  }
+  const ParsedFeaturePolicy& ParsedHeader() const { return parsed_header_; }
+
+  OriginTrialContext* GetOriginTrialContext() { return origin_trials_; }
+
+  WindowAgentFactory* GetWindowAgentFactory() { return window_agent_factory_; }
+  Agent* GetAgent() { return agent_; }
+  SecureContextMode GetSecureContextMode() {
+    return secure_context_mode_.value();
+  }
+
+  void CountFeaturePolicyUsage(mojom::WebFeature feature) override {
+    feature_count_.insert(feature);
+  }
+
+  bool FeaturePolicyFeatureObserved(mojom::FeaturePolicyFeature) override;
+  bool FeatureEnabled(OriginTrialFeature feature) const override;
+
+  void ApplyPendingDataToDocument(Document&);
+
+  bool BindCSPImmediately() const { return bind_csp_immediately_; }
+
+ private:
+  void InitializeContentSecurityPolicy(const DocumentInit&, DocumentClassFlags);
+  void InitializeOrigin(const DocumentInit&);
+  void InitializeSandboxFlags(const DocumentInit&);
+  void InitializeFeaturePolicy(const DocumentInit&, DocumentClassFlags);
+  void InitializeSecureContextMode(const DocumentInit&);
+  void InitializeOriginTrials(const DocumentInit&);
+  void InitializeAgent(const DocumentInit&);
+
+  scoped_refptr<SecurityOrigin> security_origin_;
+  WebSandboxFlags sandbox_flags_ = WebSandboxFlags::kNone;
+  std::unique_ptr<FeaturePolicy> feature_policy_;
+  std::unique_ptr<DocumentPolicy> document_policy_;
+  Vector<String> feature_policy_parse_messages_;
+  ParsedFeaturePolicy parsed_header_;
+  Member<ContentSecurityPolicy> csp_;
+  Member<OriginTrialContext> origin_trials_;
+  Member<Agent> agent_;
+  Member<WindowAgentFactory> window_agent_factory_;
+  HashSet<mojom::FeaturePolicyFeature> parsed_feature_policies_;
+  HashSet<mojom::WebFeature> feature_count_;
+  bool bind_csp_immediately_ = false;
+  base::Optional<SecureContextMode> secure_context_mode_;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_EXECUTION_CONTEXT_SECURITY_CONTEXT_INIT_H_