reflow comments in Source/bindings/core/v8

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

 /*
  * Copyright (C) 2009 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 135 matching lines @@
     accessControlStatus = SharableCrossOrigin;
 
   ErrorEvent* event =
       ErrorEvent::create(toCoreStringWithNullCheck(message->Get()),
                          std::move(location), &scriptState->world());
 
   String messageForConsole = extractMessageForConsole(isolate, data);
   if (!messageForConsole.isEmpty())
     event->setUnsanitizedMessage("Uncaught " + messageForConsole);
 
-  // This method might be called while we're creating a new context. In this case, we
-  // avoid storing the exception object, as we can't create a wrapper during context creation.
-  // FIXME: Can we even get here during initialization now that we bail out when GetEntered returns an empty handle?
+  // This method might be called while we're creating a new context. In this
+  // case, we avoid storing the exception object, as we can't create a wrapper
+  // during context creation.
+  // FIXME: Can we even get here during initialization now that we bail out when
+  // GetEntered returns an empty handle?
   if (context->isDocument()) {
     LocalFrame* frame = toDocument(context)->frame();
     if (frame && frame->script().existingWindowProxy(scriptState->world())) {
       V8ErrorHandler::storeExceptionOnErrorEventWrapper(
           scriptState, event, data, scriptState->context()->Global());
     }
   }
 
   if (scriptState->world().isPrivateScriptIsolatedWorld()) {
-    // We allow a private script to dispatch error events even in a EventDispatchForbiddenScope scope.
-    // Without having this ability, it's hard to debug the private script because syntax errors
-    // in the private script are not reported to console (the private script just crashes silently).
-    // Allowing error events in private scripts is safe because error events don't propagate to
-    // other isolated worlds (which means that the error events won't fire any event listeners
-    // in user's scripts).
+    // We allow a private script to dispatch error events even in a
+    // EventDispatchForbiddenScope scope.  Without having this ability, it's
+    // hard to debug the private script because syntax errors in the private
+    // script are not reported to console (the private script just crashes
+    // silently).  Allowing error events in private scripts is safe because
+    // error events don't propagate to other isolated worlds (which means that
+    // the error events won't fire any event listeners in user's scripts).
     EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
     context->dispatchErrorEvent(event, accessControlStatus);
   } else {
     context->dispatchErrorEvent(event, accessControlStatus);
   }
 }
 
 namespace {
 
 static RejectedPromises& rejectedPromisesOnMainThread() {
@@ skipping 18 matching lines @@
   }
 
   ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
 
   v8::Local<v8::Promise> promise = data.GetPromise();
   v8::Isolate* isolate = promise->GetIsolate();
   ExecutionContext* context = scriptState->getExecutionContext();
 
   v8::Local<v8::Value> exception = data.GetValue();
   if (V8DOMWrapper::isWrapper(isolate, exception)) {
-    // Try to get the stack & location from a wrapped exception object (e.g. DOMException).
+    // Try to get the stack & location from a wrapped exception object (e.g.
+    // DOMException).
     ASSERT(exception->IsObject());
     auto privateError = V8PrivateProperty::getDOMExceptionError(isolate);
     v8::Local<v8::Value> error = privateError.getOrUndefined(
         scriptState->context(), exception.As<v8::Object>());
     if (!error->IsUndefined())
       exception = error;
   }
 
   String errorMessage;
   AccessControlStatus corsStatus = NotSharableCrossOrigin;
@@ skipping 65 matching lines @@
 
 static void failedAccessCheckCallbackInMainThread(v8::Local<v8::Object> host,
                                                   v8::AccessType type,
                                                   v8::Local<v8::Value> data) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   Frame* target = findFrame(isolate, host, data);
   if (!target)
     return;
   DOMWindow* targetWindow = target->domWindow();
 
-  // FIXME: We should modify V8 to pass in more contextual information (context, property, and object).
+  // FIXME: We should modify V8 to pass in more contextual information (context,
+  // property, and object).
   ExceptionState exceptionState(ExceptionState::UnknownContext, 0, 0,
                                 isolate->GetCurrentContext()->Global(),
                                 isolate);
   exceptionState.throwSecurityError(
       targetWindow->sanitizedCrossDomainAccessErrorMessage(
           currentDOMWindow(isolate)),
       targetWindow->crossDomainAccessErrorMessage(currentDOMWindow(isolate)));
 }
 
 static bool codeGenerationCheckCallbackInMainThread(
@@ skipping 20 matching lines @@
   }
 
   v8::Debug::SetLiveEditEnabled(isolate, false);
 
   isolate->SetMicrotasksPolicy(v8::MicrotasksPolicy::kScoped);
 }
 
 namespace {
 
 class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
-  // Allocate() methods return null to signal allocation failure to V8, which should respond by throwing
-  // a RangeError, per http://www.ecma-international.org/ecma-262/6.0/#sec-createbytedatablock.
+  // Allocate() methods return null to signal allocation failure to V8, which
+  // should respond by throwing a RangeError, per
+  // http://www.ecma-international.org/ecma-262/6.0/#sec-createbytedatablock.
   void* Allocate(size_t size) override {
     void* data;
     WTF::ArrayBufferContents::allocateMemoryOrNull(
         size, WTF::ArrayBufferContents::ZeroInitialize, data);
     return data;
   }
 
   void* AllocateUninitialized(size_t size) override {
     void* data;
     WTF::ArrayBufferContents::allocateMemoryOrNull(
@@ skipping 79 matching lines @@
 
 void V8Initializer::shutdownMainThread() {
   ASSERT(isMainThread());
   v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
   V8PerIsolateData::willBeDestroyed(isolate);
   V8PerIsolateData::destroy(isolate);
 }
 
 static void reportFatalErrorInWorker(const char* location,
                                      const char* message) {
-  // FIXME: We temporarily deal with V8 internal error situations such as out-of-memory by crashing the worker.
+  // FIXME: We temporarily deal with V8 internal error situations such as
+  // out-of-memory by crashing the worker.
   CRASH();
 }
 
 static void messageHandlerInWorker(v8::Local<v8::Message> message,
                                    v8::Local<v8::Value> data) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   V8PerIsolateData* perIsolateData = V8PerIsolateData::from(isolate);
 
   // During the frame teardown, there may not be a valid context.
   ScriptState* scriptState = ScriptState::current(isolate);
   if (!scriptState->contextIsValid())
     return;
 
   // Exceptions that occur in error handler should be ignored since in that case
-  // WorkerGlobalScope::dispatchErrorEvent will send the exception to the worker object.
+  // WorkerGlobalScope::dispatchErrorEvent will send the exception to the worker
+  // object.
   if (perIsolateData->isReportingException())
     return;
 
   perIsolateData->setReportingException(true);
 
   ExecutionContext* context = scriptState->getExecutionContext();
   std::unique_ptr<SourceLocation> location =
       SourceLocation::fromMessage(isolate, message, context);
   ErrorEvent* event =
       ErrorEvent::create(toCoreStringWithNullCheck(message->Get()),
                          std::move(location), &scriptState->world());
 
   AccessControlStatus corsStatus = message->IsSharedCrossOrigin()
                                        ? SharableCrossOrigin
                                        : NotSharableCrossOrigin;
 
   // If execution termination has been triggered as part of constructing
   // the error event from the v8::Message, quietly leave.
   if (!isolate->IsExecutionTerminating()) {
     V8ErrorHandler::storeExceptionOnErrorEventWrapper(
         scriptState, event, data, scriptState->context()->Global());
     scriptState->getExecutionContext()->dispatchErrorEvent(event, corsStatus);
   }
 
   perIsolateData->setReportingException(false);
 }
 
 static const int kWorkerMaxStackSize = 500 * 1024;
 
-// This function uses a local stack variable to determine the isolate's stack limit. AddressSanitizer may
-// relocate that local variable to a fake stack, which may lead to problems during JavaScript execution.
-// Therefore we disable AddressSanitizer for V8Initializer::initializeWorker().
+// This function uses a local stack variable to determine the isolate's stack
+// limit. AddressSanitizer may relocate that local variable to a fake stack,
+// which may lead to problems during JavaScript execution.  Therefore we disable
+// AddressSanitizer for V8Initializer::initializeWorker().
 NO_SANITIZE_ADDRESS
 void V8Initializer::initializeWorker(v8::Isolate* isolate) {
   initializeV8Common(isolate);
 
   isolate->AddMessageListener(messageHandlerInWorker);
   isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
   uint32_t here;
   isolate->SetStackLimit(reinterpret_cast<uintptr_t>(
       &here - kWorkerMaxStackSize / sizeof(uint32_t*)));
   isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 }  // namespace blink