Replace AllowCrossThreadAccess() + non-GCed pointers with crossThreadUnretained()

third_party/WebKit/Source/core/workers/WorkerThread.cpp

 /*
  * Copyright (C) 2008 Apple 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 176 matching lines @@
 }
 
 void WorkerThread::start(std::unique_ptr<WorkerThreadStartupData> startupData)
 {
     DCHECK(isMainThread());
 
     if (m_started)
         return;
 
     m_started = true;
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::initializeOnWorkerThread, AllowCrossThreadAccess(this), passed(std::move(startupData))));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::initializeOnWorkerThread, crossThreadUnretained(this), passed(std::move(startupData))));
 }
 
 void WorkerThread::terminate()
 {
     DCHECK(isMainThread());
     terminateInternal(TerminationMode::Graceful);
 }
 
 void WorkerThread::terminateAndWait()
 {
@@ skipping 38 matching lines @@
         MutexLocker lock(m_threadStateMutex);
         if (m_terminated || m_readyToShutdown)
             return;
     }
 
     bool isInstrumented = !task->taskNameForInstrumentation().isEmpty();
     if (isInstrumented) {
         DCHECK(isCurrentThread());
         InspectorInstrumentation::asyncTaskScheduled(workerGlobalScope(), "Worker task", task.get());
     }
-    workerBackingThread().backingThread().postTask(location, threadSafeBind(&WorkerThread::performTaskOnWorkerThread, AllowCrossThreadAccess(this), passed(std::move(task)), isInstrumented));
+    workerBackingThread().backingThread().postTask(location, threadSafeBind(&WorkerThread::performTaskOnWorkerThread, crossThreadUnretained(this), passed(std::move(task)), isInstrumented));
 }
 
 void WorkerThread::appendDebuggerTask(std::unique_ptr<CrossThreadClosure> task)
 {
     DCHECK(isMainThread());
     {
         MutexLocker lock(m_threadStateMutex);
         if (m_terminated)
             return;
     }
-    m_inspectorTaskRunner->appendTask(threadSafeBind(&WorkerThread::performDebuggerTaskOnWorkerThread, AllowCrossThreadAccess(this), passed(std::move(task))));
+    m_inspectorTaskRunner->appendTask(threadSafeBind(&WorkerThread::performDebuggerTaskOnWorkerThread, crossThreadUnretained(this), passed(std::move(task))));
     {
         MutexLocker lock(m_threadStateMutex);
         if (isolate() && !m_readyToShutdown)
             m_inspectorTaskRunner->interruptAndRunAllTasksDontWait(isolate());
     }
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performDebuggerTaskDontWaitOnWorkerThread, AllowCrossThreadAccess(this)));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performDebuggerTaskDontWaitOnWorkerThread, crossThreadUnretained(this)));
 }
 
 void WorkerThread::startRunningDebuggerTasksOnPauseOnWorkerThread()
 {
     DCHECK(isCurrentThread());
     m_pausedInDebugger = true;
     ThreadDebugger::idleStarted(isolate());
     std::unique_ptr<CrossThreadClosure> task;
     do {
         {
@@ skipping 128 matching lines @@
             m_exitCode = ExitCode::SyncForciblyTerminated;
         } else {
             DCHECK_EQ(TerminationMode::Graceful, mode);
             DCHECK(!m_scheduledForceTerminationTask);
             m_scheduledForceTerminationTask = ForceTerminationTask::create(this);
             m_scheduledForceTerminationTask->schedule();
         }
     }
 
     m_inspectorTaskRunner->kill();
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::prepareForShutdownOnWorkerThread, AllowCrossThreadAccess(this)));
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performShutdownOnWorkerThread, AllowCrossThreadAccess(this)));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::prepareForShutdownOnWorkerThread, crossThreadUnretained(this)));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performShutdownOnWorkerThread, crossThreadUnretained(this)));
 }
 
 void WorkerThread::forciblyTerminateExecution()
 {
     DCHECK(m_workerGlobalScope);
     m_workerGlobalScope->scriptController()->willScheduleExecutionTermination();
     isolate()->TerminateExecution();
 }
 
 void WorkerThread::initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupData> startupData)
@@ skipping 184 matching lines @@
         (*task)();
 }
 
 WorkerThread::ExitCode WorkerThread::getExitCode()
 {
     MutexLocker lock(m_threadStateMutex);
     return m_exitCode;
 }
 
 } // namespace blink