WindowProxy::initialize should never return null

third_party/WebKit/Source/bindings/core/v8/WindowProxy.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 200 matching lines @@
 // via window.window, window.self, window.parent, etc. The outer window
 // has a security token which is the domain. The outer window cannot
 // have its own properties. window.foo = 'x' is delegated to the
 // inner window.
 //
 // When a frame navigates to a new page, the inner window is cut off
 // the outer window, and the outer window identify is preserved for
 // the frame. However, a new inner window is created for the new page.
 // If there are JS code holds a closure to the old inner window,
 // it won't be able to reach the outer window via its global object.
-bool WindowProxy::initializeIfNeeded() {
+void WindowProxy::initializeIfNeeded() {
   if (isContextInitialized())
-    return true;
-
-  return initialize();
+    return;
+  initialize();
 }
 
-bool WindowProxy::initialize() {
+void WindowProxy::initialize() {
   TRACE_EVENT1("v8", "WindowProxy::initialize", "isMainWindow",
                m_frame->isMainFrame());
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER(
       m_frame->isMainFrame() ? "Blink.Binding.InitializeMainWindowProxy"
                              : "Blink.Binding.InitializeNonMainWindowProxy");
 
   ScriptForbiddenScope::AllowUserAgentScript allowScript;
 
   v8::HandleScope handleScope(m_isolate);
 
   createContext();
-
-  if (!isContextInitialized())
-    return false;
+  CHECK(isContextInitialized());

[haraken, 2016/12/27 15:15:40]

isContextInitialized() should return true here because createContext() creates a
ScriptState and a PerContextData.
 

 
   ScriptState::Scope scope(m_scriptState.get());
   v8::Local<v8::Context> context = m_scriptState->context();
   if (m_globalProxy.isEmpty()) {
     m_globalProxy.set(m_isolate, context->Global());
-    if (m_globalProxy.isEmpty()) {
-      disposeContext(DoNotDetachGlobal);
-      return false;
-    }
+    CHECK(!m_globalProxy.isEmpty());

[haraken, 2016/12/27 15:15:40]

Unless V8 hits OOM or stack-overflow, m_globalProxy.set should not fail.

   }
 
-  if (!setupWindowPrototypeChain()) {
-    disposeContext(DoNotDetachGlobal);
-    return false;
-  }
+  setupWindowPrototypeChain();

[haraken, 2016/12/27 15:15:40]

setupWindowPrototypeChain() never returns false.

 
   SecurityOrigin* origin = 0;
   if (m_world->isMainWorld()) {
     // ActivityLogger for main world is updated within updateDocument().
     updateDocument();
     origin = m_frame->securityContext()->getSecurityOrigin();
     // FIXME: Can this be removed when CSP moves to browser?
     ContentSecurityPolicy* csp =
         m_frame->securityContext()->contentSecurityPolicy();
     context->AllowCodeGenerationFromStrings(
@@ skipping 11 matching lines @@
     MainThreadDebugger::instance()->contextCreated(m_scriptState.get(), frame,
                                                    origin);
     frame->loader().client()->didCreateScriptContext(
         context, m_world->extensionGroup(), m_world->worldId());
   }
   // If conditional features for window have been queued before the V8 context
   // was ready, then inject them into the context now
   if (m_world->isMainWorld()) {
     installPendingConditionalFeaturesOnWindow(m_scriptState.get());
   }
-
-  return true;
 }
 
 void WindowProxy::createContext() {
   // Create a new v8::Context with the window object as the global object
   // (aka the inner global).  Reuse the global proxy object (aka the outer
   // global) if it already exists.  See the comments in
   // setupWindowPrototypeChain for the structure of the prototype chain of
   // the global object.
   v8::Local<v8::ObjectTemplate> globalTemplate =
       V8Window::domTemplate(m_isolate, *m_world)->InstanceTemplate();
@@ skipping 27 matching lines @@
         V8PerIsolateData::from(m_isolate));
     context =
         v8::Context::New(m_isolate, &extensionConfiguration, globalTemplate,
                          m_globalProxy.newLocal(m_isolate));
   }
   CHECK(!context.IsEmpty());
 
   m_scriptState = ScriptState::create(context, m_world);
 }
 
-bool WindowProxy::setupWindowPrototypeChain() {
+void WindowProxy::setupWindowPrototypeChain() {
   // Associate the window wrapper object and its prototype chain with the
   // corresponding native DOMWindow object.
   // The full structure of the global object's prototype chain is as follows:
   //
   // global proxy object [1]
   //   -- has prototype --> global object (window wrapper object) [2]
   //   -- has prototype --> Window.prototype
   //   -- has prototype --> WindowProperties [3]
   //   -- has prototype --> EventTarget.prototype
   //   -- has prototype --> Object.prototype
@@ skipping 44 matching lines @@
   v8::Local<v8::Object> windowProperties =
       windowPrototype->GetPrototype().As<v8::Object>();
   CHECK(!windowProperties.IsEmpty());
   V8DOMWrapper::setNativeInfo(m_isolate, windowProperties, wrapperTypeInfo,
                               window);
 
   // TODO(keishi): Remove installPagePopupController and implement
   // PagePopupController in another way.
   V8PagePopupControllerBinding::installPagePopupController(context,
                                                            windowWrapper);
-  return true;
 }
 
 void WindowProxy::updateDocumentProperty() {
   DCHECK(m_world->isMainWorld());
 
   if (m_frame->isRemoteFrame())
     return;
 
   ScriptState::Scope scope(m_scriptState.get());
   v8::Local<v8::Context> context = m_scriptState->context();
@@ skipping 157 matching lines @@
       .ToChecked();
 }
 
 void WindowProxy::updateSecurityOrigin(SecurityOrigin* origin) {
   if (!isContextInitialized())
     return;
   setSecurityToken(origin);
 }
 
 }  // namespace blink