Revert of [Bindings] Create and use V8 context snapshots

third_party/WebKit/Source/bindings/core/v8/LocalWindowProxy.cpp

 /*
  * Copyright (C) 2008, 2009, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "bindings/core/v8/LocalWindowProxy.h"
 
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8BindingForCore.h"
-#include "bindings/core/v8/V8ContextSnapshot.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "bindings/core/v8/V8GCForContextDispose.h"
 #include "bindings/core/v8/V8HTMLDocument.h"
 #include "bindings/core/v8/V8Initializer.h"
 #include "bindings/core/v8/V8PagePopupControllerBinding.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/dom/Modulator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
@@ skipping 61 matching lines @@
     // The context's frame is detached from the DOM, so there shouldn't be a
     // strong reference to the context.
     global_proxy_.SetPhantom();
   }
 
   DCHECK_EQ(lifecycle_, Lifecycle::kContextIsInitialized);
   lifecycle_ = next_status;
 }
 
 void LocalWindowProxy::Initialize() {
-  TRACE_EVENT1("v8", "LocalWindowProxy::Initialize", "IsMainFrame",
+  TRACE_EVENT1("v8", "LocalWindowProxy::initialize", "isMainWindow",
                GetFrame()->IsMainFrame());
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER(
       GetFrame()->IsMainFrame()
           ? "Blink.Binding.InitializeMainLocalWindowProxy"
           : "Blink.Binding.InitializeNonMainLocalWindowProxy");
 
   ScriptForbiddenScope::AllowUserAgentScript allow_script;
 
   v8::HandleScope handle_scope(GetIsolate());
 
   CreateContext();
 
   ScriptState::Scope scope(script_state_.Get());
   v8::Local<v8::Context> context = script_state_->GetContext();
   if (global_proxy_.IsEmpty()) {
     global_proxy_.Set(GetIsolate(), context->Global());
     CHECK(!global_proxy_.IsEmpty());
   }
 
   SetupWindowPrototypeChain();
-  V8ContextSnapshot::InstallRuntimeEnabledFeatures(context,
-                                                   GetFrame()->GetDocument());
 
   SecurityOrigin* origin = 0;
   if (world_->IsMainWorld()) {
     // ActivityLogger for main world is updated within updateDocumentInternal().
     UpdateDocumentInternal();
     origin = GetFrame()->GetDocument()->GetSecurityOrigin();
     // FIXME: Can this be removed when CSP moves to browser?
     ContentSecurityPolicy* csp =
         GetFrame()->GetDocument()->GetContentSecurityPolicy();
     context->AllowCodeGenerationFromStrings(csp->AllowEval(
         0, SecurityViolationReportingPolicy::kSuppressReporting,
         ContentSecurityPolicy::kWillNotThrowException, g_empty_string));
     context->SetErrorMessageForCodeGenerationFromStrings(
         V8String(GetIsolate(), csp->EvalDisabledErrorMessage()));
   } else {
     UpdateActivityLogger();
     origin = world_->IsolatedWorldSecurityOrigin();
     SetSecurityToken(origin);
   }
 
-  {
-    TRACE_EVENT1("v8", "ContextCreatedNotification", "IsMainFrame",
-                 GetFrame()->IsMainFrame());
-    MainThreadDebugger::Instance()->ContextCreated(script_state_.Get(),
-                                                   GetFrame(), origin);
-    GetFrame()->Client()->DidCreateScriptContext(context, world_->GetWorldId());
+  MainThreadDebugger::Instance()->ContextCreated(script_state_.Get(),
+                                                 GetFrame(), origin);
+  GetFrame()->Client()->DidCreateScriptContext(context, world_->GetWorldId());
 
-    InstallConditionalFeaturesOnGlobal(&V8Window::wrapperTypeInfo,
-                                       script_state_.Get());
+  InstallConditionalFeaturesOnGlobal(&V8Window::wrapperTypeInfo,
+                                     script_state_.Get());
 
-    if (world_->IsMainWorld()) {
-      // For the main world, install any remaining conditional bindings (i.e.
-      // for origin trials, which do not apply to extensions). Some conditional
-      // bindings cannot be enabled until the execution context is available
-      // (e.g. parsing the document, inspecting HTTP headers).
-      InstallConditionalFeatures(&V8Window::wrapperTypeInfo,
-                                 script_state_.Get(), v8::Local<v8::Object>(),
-                                 v8::Local<v8::Function>());
-      GetFrame()->Loader().DispatchDidClearWindowObjectInMainWorld();
-    }
+  if (world_->IsMainWorld()) {
+    // For the main world, install any remaining conditional bindings (i.e. for
+    // origin trials, which do not apply to extensions). Some conditional
+    // bindings cannot be enabled until the execution context is available
+    // (e.g. parsing the document, inspecting HTTP headers).
+    InstallConditionalFeatures(&V8Window::wrapperTypeInfo, script_state_.Get(),
+                               v8::Local<v8::Object>(),
+                               v8::Local<v8::Function>());
+    GetFrame()->Loader().DispatchDidClearWindowObjectInMainWorld();
   }
 }
 
 void LocalWindowProxy::CreateContext() {
-  TRACE_EVENT1("v8", "LocalWindowProxy::CreateContext", "IsMainFrame",
-               GetFrame()->IsMainFrame());
+  // Create a new v8::Context with the window object as the global object
+  // (aka the inner global). Reuse the outer global proxy if it already exists.
+  v8::Local<v8::ObjectTemplate> global_template =
+      V8Window::domTemplate(GetIsolate(), *world_)->InstanceTemplate();
+  CHECK(!global_template.IsEmpty());
 
   Vector<const char*> extension_names;
   // Dynamically tell v8 about our extensions now.
   if (GetFrame()->Client()->AllowScriptExtensions()) {
     const V8Extensions& extensions = ScriptController::RegisteredExtensions();
     extension_names.ReserveInitialCapacity(extensions.size());
     for (const auto* extension : extensions)
       extension_names.push_back(extension->name());
   }
   v8::ExtensionConfiguration extension_configuration(extension_names.size(),
                                                      extension_names.data());
 
   v8::Local<v8::Context> context;
   {
-    v8::Isolate* isolate = GetIsolate();
-    Document* document = GetFrame()->GetDocument();
     V8PerIsolateData::UseCounterDisabledScope use_counter_disabled(
-        V8PerIsolateData::From(isolate));
-
-    v8::Local<v8::Object> global_proxy = global_proxy_.NewLocal(isolate);
-    context = V8ContextSnapshot::CreateContextFromSnapshot(
-        isolate, World(), &extension_configuration, global_proxy, document);
-
-    // Even if we enable V8 context snapshot feature, we may hit this branch
-    // in some cases, e.g. loading XML files.
-    if (context.IsEmpty()) {
-      v8::Local<v8::ObjectTemplate> global_template =
-          V8Window::domTemplate(isolate, *world_)->InstanceTemplate();
-      CHECK(!global_template.IsEmpty());
-      context = v8::Context::New(isolate, &extension_configuration,
-                                 global_template, global_proxy);
-      VLOG(1) << "A context is created NOT from snapshot";
-    }
+        V8PerIsolateData::From(GetIsolate()));
+    context =
+        v8::Context::New(GetIsolate(), &extension_configuration,
+                         global_template, global_proxy_.NewLocal(GetIsolate()));
   }
   CHECK(!context.IsEmpty());
 
 #if DCHECK_IS_ON()
   DidAttachGlobalObject();
 #endif
 
   script_state_ = ScriptState::Create(context, world_);
 
   DCHECK(lifecycle_ == Lifecycle::kContextIsUninitialized ||
          lifecycle_ == Lifecycle::kGlobalObjectIsDetached);
   lifecycle_ = Lifecycle::kContextIsInitialized;
   DCHECK(script_state_->ContextIsValid());
 }
 
 void LocalWindowProxy::SetupWindowPrototypeChain() {
-  TRACE_EVENT1("v8", "LocalWindowProxy::SetupWindowPrototypeChain",
-               "IsMainFrame", GetFrame()->IsMainFrame());
-
   // Associate the window wrapper object and its prototype chain with the
   // corresponding native DOMWindow object.
   DOMWindow* window = GetFrame()->DomWindow();
   const WrapperTypeInfo* wrapper_type_info = window->GetWrapperTypeInfo();
   v8::Local<v8::Context> context = script_state_->GetContext();
 
   // The global proxy object.  Note this is not the global object.
   v8::Local<v8::Object> global_proxy = context->Global();
   CHECK(global_proxy_ == global_proxy);
   V8DOMWrapper::SetNativeInfo(GetIsolate(), global_proxy, wrapper_type_info,
@@ skipping 24 matching lines @@
                               wrapper_type_info, window);
 
   // TODO(keishi): Remove installPagePopupController and implement
   // PagePopupController in another way.
   V8PagePopupControllerBinding::InstallPagePopupController(context,
                                                            window_wrapper);
 }
 
 void LocalWindowProxy::UpdateDocumentProperty() {
   DCHECK(world_->IsMainWorld());
-  TRACE_EVENT1("v8", "LocalWindowProxy::UpdateDocumentProperty", "IsMainFrame",
-               GetFrame()->IsMainFrame());
 
   ScriptState::Scope scope(script_state_.Get());
   v8::Local<v8::Context> context = script_state_->GetContext();
   v8::Local<v8::Value> document_wrapper =
       ToV8(GetFrame()->GetDocument(), context->Global(), GetIsolate());
   DCHECK(document_wrapper->IsObject());
-
   // Update the cached accessor for window.document.
   CHECK(V8PrivateProperty::GetWindowDocumentCachedAccessor(GetIsolate())
             .Set(context->Global(), document_wrapper));
 }
 
 void LocalWindowProxy::UpdateActivityLogger() {
   script_state_->PerContextData()->SetActivityLogger(
       V8DOMActivityLogger::ActivityLogger(
           world_->GetWorldId(), GetFrame()->GetDocument()
                                     ? GetFrame()->GetDocument()->baseURI()
@@ skipping 41 matching lines @@
     context->UseDefaultSecurityToken();
     return;
   }
 
   if (world_->IsIsolatedWorld()) {
     SecurityOrigin* frame_security_origin =
         GetFrame()->GetDocument()->GetSecurityOrigin();
     String frame_security_token = frame_security_origin->ToString();
     // We need to check the return value of domainWasSetInDOM() on the
     // frame's SecurityOrigin because, if that's the case, only
-    // SecurityOrigin::domain_ would have been modified.
-    // domain_ is not used by SecurityOrigin::toString(), so we would end
+    // SecurityOrigin::m_domain would have been modified.
+    // m_domain is not used by SecurityOrigin::toString(), so we would end
     // up generating the same token that was already set.
     if (frame_security_origin->DomainWasSetInDOM() ||
         frame_security_token.IsEmpty() || frame_security_token == "null") {
       context->UseDefaultSecurityToken();
       return;
     }
     token = frame_security_token + token;
   }
 
   // NOTE: V8 does identity comparison in fast path, must use a symbol
@@ skipping 129 matching lines @@
 
   SetSecurityToken(origin);
 }
 
 LocalWindowProxy::LocalWindowProxy(v8::Isolate* isolate,
                                    LocalFrame& frame,
                                    RefPtr<DOMWrapperWorld> world)
     : WindowProxy(isolate, frame, std::move(world)) {}
 
 }  // namespace blink