自学教程：C++ AllowCrossThreadAccess函数代码示例

void WorkerFileSystemCallbacksBridge::postCreateFileToMainThread(WebFileSystem* fileSystem, const KURL& path, bool exclusive, const String& mode){    dispatchTaskToMainThread(        createCallbackTask(&createFileOnMainThread,                           AllowCrossThreadAccess(fileSystem), path, exclusive,                           this, mode));}

void AsyncFileStream::startOnFileThread(){    // FIXME: It is not correct to check m_client from a secondary thread - stop() could be racing with this check.    if (!m_client)        return;    m_stream->start();    callOnMainThread(didStart, AllowCrossThreadAccess(this));}

DataConsumerHandleTestUtil::Thread::Thread(const char* name, InitializationPolicy initializationPolicy)    : m_thread(WebThreadSupportingGC::create(name))    , m_initializationPolicy(initializationPolicy)    , m_waitableEvent(adoptPtr(Platform::current()->createWaitableEvent())){    m_thread->postTask(BLINK_FROM_HERE, new Task(threadSafeBind(&Thread::initialize, AllowCrossThreadAccess(this))));    m_waitableEvent->wait();}

void WorkerFileSystemCallbacksBridge::postCreateSnapshotFileToMainThread(WebFileSystem* fileSystem, const KURL& path, const String& mode){    ASSERT(fileSystem);    dispatchTaskToMainThread(        createCallbackTask(&createSnapshotFileOnMainThread,                           AllowCrossThreadAccess(fileSystem),                           path, this, mode));}

void WebWorkerClientImpl::confirmMessageFromWorkerObject(bool hasPendingActivity){    // unconfirmed_message_count_ can only be updated on the thread where it's    // accessed.  Otherwise there are race conditions with v8's garbage    // collection.    m_scriptExecutionContext->postTask(createCallbackTask(&confirmMessageFromWorkerObjectTask,                                                          AllowCrossThreadAccess(this)));}

void WorkerThreadableLoader::MainThreadBridge::destroy(){    // Ensure that no more client callbacks are done in the worker context's thread.    clearClientWrapper();    // "delete this" and m_mainThreadLoader::deref() on the worker object's thread.    m_loaderProxy.postTaskToLoader(        createCallbackTask(&MainThreadBridge::mainThreadDestroy, AllowCrossThreadAccess(this)));}

void HTMLParserThread::postTask(PassOwnPtr<CrossThreadClosure> closure){    ASSERT(isMainThread());    if (!m_thread) {        m_thread = WebThreadSupportingGC::create("HTMLParserThread");        postTask(threadSafeBind(&HTMLParserThread::setupHTMLParserThread, AllowCrossThreadAccess(this)));    }    m_thread->postTask(BLINK_FROM_HERE, closure);}

void WebWorkerBase::postConsoleMessageToWorkerObject(MessageSource source,                                                     MessageType type,                                                     MessageLevel level,                                                     const String& message,                                                     int lineNumber,                                                     const String& sourceURL){    dispatchTaskToMainThread(createCallbackTask(&postConsoleMessageTask, AllowCrossThreadAccess(this),                                                source, type, level,                                                message, lineNumber, sourceURL));}

WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, WorkerLoaderProxy& loaderProxy, const String& taskMode,                                                           const ResourceRequest& request, const ThreadableLoaderOptions& options, const String& outgoingReferrer)    : m_workerClientWrapper(workerClientWrapper)    , m_loaderProxy(loaderProxy)    , m_taskMode(taskMode.isolatedCopy()){    ASSERT(m_workerClientWrapper.get());    m_loaderProxy.postTaskToLoader(        createCallbackTask(&MainThreadBridge::mainThreadCreateLoader,                            AllowCrossThreadAccess(this), request, options, outgoingReferrer));}

void WorkerThreadableWebSocketChannel::Bridge::initialize(){    ASSERT(!m_peer);    setMethodNotCompleted();    Ref<Bridge> protect(*this);    m_loaderProxy.postTaskToLoader(CrossThreadTask(&Bridge::mainThreadInitialize, AllowCrossThreadAccess(&m_loaderProxy), m_workerClientWrapper, m_taskMode));    waitForMethodCompletion();    // m_peer may be null when the nested runloop exited before a peer has created.    m_peer = m_workerClientWrapper->peer();    if (!m_peer)        m_workerClientWrapper->setFailedWebSocketChannelCreation();}

void WebWorkerClientImpl::terminateWorkerContext(){    if (m_askedToTerminate)        return;    m_askedToTerminate = true;    if (!isMainThread()) {        WebWorkerBase::dispatchTaskToMainThread(            createCallbackTask(&terminateWorkerContextTask, AllowCrossThreadAccess(this)));        return;    }    m_webWorker->terminateWorkerContext();}

void WorkerThreadableLoader::MainThreadBridge::cancel(){    m_loaderProxy.postTaskToLoader(        createCallbackTask(&MainThreadBridge::mainThreadCancel, AllowCrossThreadAccess(this)));    ThreadableLoaderClientWrapper* clientWrapper = m_workerClientWrapper.get();    if (!clientWrapper->done()) {        // If the client hasn't reached a termination state, then transition it by sending a cancellation error.        // Note: no more client callbacks will be done after this method -- the clearClientWrapper() call ensures that.        ResourceError error(String(), 0, String(), String());        error.setIsCancellation(true);        clientWrapper->didFail(error);    }    clearClientWrapper();}

bool CCThreadProxy::initializeLayerRenderer(){    RefPtr<GraphicsContext3D> context = m_layerTreeHost->createLayerTreeHostContext3D();    if (!context)        return false;    ASSERT(context->hasOneRef());    // Leak the context pointer so we can transfer ownership of it to the other side...    GraphicsContext3D* contextPtr = context.release().leakRef();    ASSERT(contextPtr->hasOneRef());    // Make a blocking call to initializeLayerRendererOnCCThread. The results of that call    // are pushed into the initializeSucceeded and capabilities local variables.    CCCompletionEvent completion;    bool initializeSucceeded;    LayerRendererCapabilities capabilities;    ccThread->postTask(createCCThreadTask(this, &CCThreadProxy::initializeLayerRendererOnCCThread,                                          AllowCrossThreadAccess(contextPtr), AllowCrossThreadAccess(&completion), AllowCrossThreadAccess(&initializeSucceeded), AllowCrossThreadAccess(&capabilities)));    completion.wait();    if (initializeSucceeded)        m_layerRendererCapabilitiesMainThreadCopy = capabilities;    return initializeSucceeded;}

bool CCThreadProxy::recreateContext(){    TRACE_EVENT0("cc", "CCThreadProxy::recreateContext");    ASSERT(isMainThread());    // Try to create the context.    RefPtr<GraphicsContext3D> context = m_layerTreeHost->createContext();    if (!context)        return false;    if (CCLayerTreeHost::needsFilterContext())        if (!SharedGraphicsContext3D::createForImplThread())            return false;    ASSERT(context->hasOneRef());    // Leak the context pointer so we can transfer ownership of it to the other side...    GraphicsContext3D* contextPtr = context.release().leakRef();    ASSERT(contextPtr->hasOneRef());    // Make a blocking call to recreateContextOnImplThread. The results of that    // call are pushed into the recreateSucceeded and capabilities local    // variables.    CCCompletionEvent completion;    bool recreateSucceeded = false;    LayerRendererCapabilities capabilities;    CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,                                                       AllowCrossThreadAccess(&completion),                                                       AllowCrossThreadAccess(contextPtr),                                                       AllowCrossThreadAccess(&recreateSucceeded),                                                       AllowCrossThreadAccess(&capabilities)));    completion.wait();    if (recreateSucceeded)        m_layerRendererCapabilitiesMainThreadCopy = capabilities;    return recreateSucceeded;}

WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(    PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper,    PassOwnPtr<ThreadableLoaderClient> clientBridge,    WorkerLoaderProxy& loaderProxy,    const ResourceRequest& request,    const ThreadableLoaderOptions& options,    const ResourceLoaderOptions& resourceLoaderOptions,    const String& outgoingReferrer)    : m_clientBridge(clientBridge)    , m_workerClientWrapper(workerClientWrapper)    , m_loaderProxy(loaderProxy){    ASSERT(m_workerClientWrapper.get());    ASSERT(m_clientBridge.get());    m_loaderProxy.postTaskToLoader(        createCrossThreadTask(&MainThreadBridge::mainThreadCreateLoader, AllowCrossThreadAccess(this), request, options, resourceLoaderOptions, outgoingReferrer));}

void WebWorkerImpl::postMessageToWorkerContext(const WebString& message,                                               const WebMessagePortChannelArray& webChannels){    OwnPtr<MessagePortChannelArray> channels;    if (webChannels.size()) {        channels = new MessagePortChannelArray(webChannels.size());        for (size_t i = 0; i < webChannels.size(); ++i) {            RefPtr<PlatformMessagePortChannel> platform_channel =                PlatformMessagePortChannel::create(webChannels[i]);            webChannels[i]->setClient(platform_channel.get());            (*channels)[i] = MessagePortChannel::create(platform_channel);        }    }    workerThread()->runLoop().postTask(        createCallbackTask(&postMessageToWorkerContextTask,                           AllowCrossThreadAccess(this), String(message), channels.release()));}

TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesCompleteMultiThreaded){    setFrameStatus(ImageFrame::FramePartial);    char buffer[100 * 100 * 4];    m_generator->decodeAndScale(imageInfo(), 0, buffer, 100 * 4);    EXPECT_EQ(1, m_decodeRequestCount);    EXPECT_EQ(0, m_decodersDestroyed);    // LocalFrame can now be decoded completely.    setFrameStatus(ImageFrame::FrameComplete);    addNewData();    OwnPtr<WebThread> thread = adoptPtr(Platform::current()->createThread("DecodeThread"));    thread->postTask(FROM_HERE, new Task(threadSafeBind(&decodeThreadMain, AllowCrossThreadAccess(m_generator.get()))));    thread.clear();    EXPECT_EQ(2, m_decodeRequestCount);    EXPECT_EQ(1, m_decodersDestroyed);    // Decoder created again.    m_generator->decodeAndScale(imageInfo(), 0, buffer, 100 * 4);    EXPECT_EQ(3, m_decodeRequestCount);}