Replace ASSERT*() with DCHECK*() in core/fetch/ and core/loader/

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/ThreadableLoader.h"
 
 #include "core/dom/ExecutionContextTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 177 matching lines @@
                 &WorkerThreadableLoaderTestHelper::workerStartLoader,
                 crossThreadUnretained(this),
                 crossThreadUnretained(completionEvent.get()),
                 request));
         completionEvent->wait();
     }
 
     // Must be called on the worker thread.
     void cancelLoader() override
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
         m_loader->cancel();
     }
 
     void cancelAndClearLoader() override
     {
         DCHECK(m_workerThread);
         DCHECK(m_workerThread->isCurrentThread());
         m_loader->cancel();
         m_loader = nullptr;
     }
 
     // Must be called on the worker thread.
     void clearLoader() override
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
         m_loader = nullptr;
     }
 
     Checkpoint& checkpoint() override
     {
         return m_checkpoint;
     }
 
     void callCheckpoint(int n) override
     {
@@ skipping 48 matching lines @@
     void expectWorkerLifetimeReportingCalls()
     {
         EXPECT_CALL(*m_mockWorkerReportingProxy, workerGlobalScopeStarted(_)).Times(1);
         EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(true)).Times(1);
         EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated()).Times(1);
         EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope()).Times(1);
     }
 
     void workerCreateLoader(ThreadableLoaderClient* client, WaitableEvent* event, CrossOriginRequestPolicy crossOriginRequestPolicy)
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
 
         ThreadableLoaderOptions options;
         options.crossOriginRequestPolicy = crossOriginRequestPolicy;
         ResourceLoaderOptions resourceLoaderOptions;
 
         // Ensure that WorkerThreadableLoader is created.
         // ThreadableLoader::create() determines whether it should create
         // a DocumentThreadableLoader or WorkerThreadableLoader based on
         // isWorkerGlobalScope().
         DCHECK(m_workerThread->globalScope()->isWorkerGlobalScope());
 
         m_loader = ThreadableLoader::create(*m_workerThread->globalScope(), client, options, resourceLoaderOptions);
-        ASSERT(m_loader);
+        DCHECK(m_loader);
         event->signal();
     }
 
     void workerStartLoader(WaitableEvent* event, std::unique_ptr<CrossThreadResourceRequestData> requestData)
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
 
         ResourceRequest request(requestData.get());
         m_loader->start(request);
         event->signal();
     }
 
     void workerCallCheckpoint(WaitableEvent* event, int n)
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
         m_checkpoint.Call(n);
         event->signal();
     }
 
     // WorkerLoaderProxyProvider methods.
     void postTaskToLoader(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task) override
     {
-        ASSERT(m_workerThread);
-        ASSERT(m_workerThread->isCurrentThread());
+        DCHECK(m_workerThread);
+        DCHECK(m_workerThread->isCurrentThread());
         document().postTask(location, std::move(task));
     }
 
     void postTaskToWorkerGlobalScope(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task) override
     {
-        ASSERT(m_workerThread);
+        DCHECK(m_workerThread);
         m_workerThread->postTask(location, std::move(task));
     }
 
     RefPtr<SecurityOrigin> m_securityOrigin;
     std::unique_ptr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
     std::unique_ptr<WorkerThreadForTest> m_workerThread;
 
     std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Checkpoint m_checkpoint;
     // |m_loader| must be touched only from the worker thread only.
@@ skipping 530 matching lines @@
     // test is not saying that didFailAccessControlCheck should be dispatched
     // synchronously, but is saying that even when a response is served
     // synchronously it should not lead to a crash.
     startLoader(KURL(KURL(), "about:blank"));
     callCheckpoint(2);
 }
 
 } // namespace
 
 } // namespace blink