DevTools: deoilpanize inspector/v8 and related classes.

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 78 matching lines @@
     return 0;
 }
 
 static void reportFatalErrorInMainThread(const char* location, const char* message)
 {
     int memoryUsageMB = Platform::current()->actualMemoryUsageMB();
     printf("V8 error: %s (%s).  Current memory usage: %d MB\n", message, location, memoryUsageMB);
     CRASH();
 }
 
-static PassRefPtrWillBeRawPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
+static PassRefPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
 {
     v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
-    RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
+    RefPtr<ScriptCallStack> callStack = nullptr;
     *scriptId = message->GetScriptOrigin().ScriptID()->Value();
     // Currently stack trace is only collected when inspector is open.
     if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
         callStack = createScriptCallStack(isolate, stackTrace, ScriptCallStack::maxCallStackSizeToCapture);
         bool success = false;
         int topScriptId = callStack->at(0).scriptId().toInt(&success);
         if (success && topScriptId == *scriptId)
             *scriptId = 0;
     }
     return callStack.release();
@@ skipping 23 matching lines @@
 static void messageHandlerInMainThread(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
 {
     ASSERT(isMainThread());
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     // If called during context initialization, there will be no entered window.
     LocalDOMWindow* enteredWindow = enteredDOMWindow(isolate);
     if (!enteredWindow || !enteredWindow->isCurrentlyDisplayedInFrame())
         return;
 
     int scriptId = 0;
-    RefPtrWillBeRawPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
+    RefPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
     String resourceName = extractResourceName(message, enteredWindow->document());
     AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
     if (message->IsOpaque())
         accessControlStatus = OpaqueResource;
     else if (message->IsSharedCrossOrigin())
         accessControlStatus = SharableCrossOrigin;
 
     ScriptState* scriptState = ScriptState::current(isolate);
     String errorMessage = toCoreStringWithNullCheck(message->Get());
     int lineNumber = 0;
@@ skipping 27 matching lines @@
     } else {
         enteredWindow->document()->reportException(event.release(), scriptId, callStack, accessControlStatus);
     }
 }
 
 namespace {
 
 static RejectedPromises& rejectedPromisesOnMainThread()
 {
     ASSERT(isMainThread());
-    DEFINE_STATIC_LOCAL(RefPtrWillBePersistent<RejectedPromises>, rejectedPromises, (RejectedPromises::create()));
+    DEFINE_STATIC_LOCAL(RefPtr<RejectedPromises>, rejectedPromises, (RejectedPromises::create()));
     return *rejectedPromises;
 }
 
 } // namespace
 
 void V8Initializer::reportRejectedPromisesOnMainThread()
 {
     rejectedPromisesOnMainThread().processQueue();
 }
 
@@ skipping 19 matching lines @@
         if (!error.IsEmpty())
             exception = error;
     }
 
     int scriptId = 0;
     int lineNumber = 0;
     int columnNumber = 0;
     String resourceName = fallbackResourceName;
     String errorMessage;
     AccessControlStatus corsStatus = NotSharableCrossOrigin;
-    RefPtrWillBeRawPtr<ScriptCallStack> callStack = nullptr;
+    RefPtr<ScriptCallStack> callStack;
 
     v8::Local<v8::Message> message = v8::Exception::CreateMessage(isolate, exception);
     if (!message.IsEmpty()) {
         V8StringResource<> v8ResourceName(message->GetScriptOrigin().ResourceName());
         if (v8ResourceName.prepare())
             resourceName = v8ResourceName;
         scriptId = message->GetScriptOrigin().ScriptID()->Value();
         if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
             && v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
             ++columnNumber;
@@ skipping 156 matching lines @@
     if (perIsolateData->isReportingException())
         return;
     perIsolateData->setReportingException(true);
 
     ScriptState* scriptState = ScriptState::current(isolate);
     // During the frame teardown, there may not be a valid context.
     if (ExecutionContext* context = scriptState->executionContext()) {
         String errorMessage = toCoreStringWithNullCheck(message->Get());
         TOSTRING_VOID(V8StringResource<>, sourceURL, message->GetScriptOrigin().ResourceName());
         int scriptId = 0;
-        RefPtrWillBeRawPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
+        RefPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
 
         int lineNumber = 0;
         int columnNumber = 0;
         if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
             && v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
             ++columnNumber;
         RefPtrWillBeRawPtr<ErrorEvent> event = ErrorEvent::create(errorMessage, sourceURL, lineNumber, columnNumber, &DOMWrapperWorld::current(isolate));
         AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
 
         // If execution termination has been triggered as part of constructing
@@ skipping 19 matching lines @@
 
     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