Replace ASSERT with DCHECK in modules/

third_party/WebKit/Source/modules/cachestorage/Cache.cpp

 // Copyright 2014 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 "modules/cachestorage/Cache.h"
 
 #include <memory>
 #include <utility>
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
@@ skipping 370 matching lines @@
 
 Cache* Cache::Create(GlobalFetch::ScopedFetcher* fetcher,
                      std::unique_ptr<WebServiceWorkerCache> web_cache) {
   return new Cache(fetcher, std::move(web_cache));
 }
 
 ScriptPromise Cache::match(ScriptState* script_state,
                            const RequestInfo& request,
                            const CacheQueryOptions& options,
                            ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   if (request.isRequest())
     return MatchImpl(script_state, request.getAsRequest(), options);
   Request* new_request =
       Request::Create(script_state, request.getAsUSVString(), exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   return MatchImpl(script_state, new_request, options);
 }
 
 ScriptPromise Cache::matchAll(ScriptState* script_state,
                               ExceptionState& exception_state) {
   return MatchAllImpl(script_state);
 }
 
 ScriptPromise Cache::matchAll(ScriptState* script_state,
                               const RequestInfo& request,
                               const CacheQueryOptions& options,
                               ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   if (request.isRequest())
     return MatchAllImpl(script_state, request.getAsRequest(), options);
   Request* new_request =
       Request::Create(script_state, request.getAsUSVString(), exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   return MatchAllImpl(script_state, new_request, options);
 }
 
 ScriptPromise Cache::add(ScriptState* script_state,
                          const RequestInfo& request,
                          ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   HeapVector<Member<Request>> requests;
   if (request.isRequest()) {
     requests.push_back(request.getAsRequest());
   } else {
     requests.push_back(Request::Create(script_state, request.getAsUSVString(),
                                        exception_state));
     if (exception_state.HadException())
       return ScriptPromise();
   }
 
@@ skipping 15 matching lines @@
     }
   }
 
   return AddAllImpl(script_state, requests, exception_state);
 }
 
 ScriptPromise Cache::deleteFunction(ScriptState* script_state,
                                     const RequestInfo& request,
                                     const CacheQueryOptions& options,
                                     ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   if (request.isRequest())
     return DeleteImpl(script_state, request.getAsRequest(), options);
   Request* new_request =
       Request::Create(script_state, request.getAsUSVString(), exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   return DeleteImpl(script_state, new_request, options);
 }
 
 ScriptPromise Cache::put(ScriptState* script_state,
                          const RequestInfo& request,
                          Response* response,
                          ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   if (request.isRequest())
     return PutImpl(script_state,
                    HeapVector<Member<Request>>(1, request.getAsRequest()),
                    HeapVector<Member<Response>>(1, response));
   Request* new_request =
       Request::Create(script_state, request.getAsUSVString(), exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   return PutImpl(script_state, HeapVector<Member<Request>>(1, new_request),
                  HeapVector<Member<Response>>(1, response));
 }
 
 ScriptPromise Cache::keys(ScriptState* script_state, ExceptionState&) {
   return KeysImpl(script_state);
 }
 
 ScriptPromise Cache::keys(ScriptState* script_state,
                           const RequestInfo& request,
                           const CacheQueryOptions& options,
                           ExceptionState& exception_state) {
-  ASSERT(!request.isNull());
+  DCHECK(!request.isNull());
   if (request.isRequest())
     return KeysImpl(script_state, request.getAsRequest(), options);
   Request* new_request =
       Request::Create(script_state, request.getAsUSVString(), exception_state);
   if (exception_state.HadException())
     return ScriptPromise();
   return KeysImpl(script_state, new_request, options);
 }
 
 // static
@@ skipping 125 matching lines @@
     if (!url.ProtocolIsInHTTPFamily()) {
       barrier_callback->OnError("Request scheme '" + url.Protocol() +
                                 "' is unsupported");
       return promise;
     }
     if (requests[i]->method() != HTTPNames::GET) {
       barrier_callback->OnError("Request method '" + requests[i]->method() +
                                 "' is unsupported");
       return promise;
     }
-    ASSERT(!requests[i]->HasBody());
+    DCHECK(!requests[i]->HasBody());
 
     if (VaryHeaderContainsAsterisk(responses[i])) {
       barrier_callback->OnError("Vary header contains *");
       return promise;
     }
     if (responses[i]->status() == 206) {
       barrier_callback->OnError(
           "Partial response (status code 206) is unsupported");
       return promise;
     }
@@ skipping 49 matching lines @@
       WTF::MakeUnique<CacheWithRequestsCallbacks>(resolver), web_request,
       ToWebQueryParams(options));
   return promise;
 }
 
 WebServiceWorkerCache* Cache::WebCache() const {
   return web_cache_.get();
 }
 
 }  // namespace blink