Replace ASSERT with DCHECK in modules/fetch.

third_party/WebKit/Source/modules/fetch/Request.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/fetch/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 314 matching lines @@
     if (!request->integrity().isEmpty()) {
       exceptionState.throwTypeError(
           "The integrity attribute is unsupported in no-cors mode.");
       return nullptr;
     }
     // "Set |r|'s Headers object's guard to "request-no-cors"."
     r->getHeaders()->setGuard(Headers::RequestNoCORSGuard);
   }
   // "Fill |r|'s Headers object with |headers|. Rethrow any exceptions."
   if (init.headers) {
-    ASSERT(init.headersDictionary.isUndefinedOrNull());
+    DCHECK(init.headersDictionary.isUndefinedOrNull());
     r->getHeaders()->fillWith(init.headers.get(), exceptionState);
   } else if (!init.headersDictionary.isUndefinedOrNull()) {
     r->getHeaders()->fillWith(init.headersDictionary, exceptionState);
   } else {
-    ASSERT(headers);
+    DCHECK(headers);
     r->getHeaders()->fillWith(headers, exceptionState);
   }
   if (exceptionState.hadException())
     return nullptr;
 
   // "If either |init|'s body member is present or |temporaryBody| is
   // non-null, and |request|'s method is `GET` or `HEAD`, throw a TypeError.
   if (init.body || temporaryBody ||
       request->credentials() == WebURLRequest::FetchCredentialsModePassword) {
     if (request->method() == HTTPNames::GET ||
@@ skipping 68 matching lines @@
   }
 
   // "Return |r|."
   return r;
 }
 
 Request* Request::create(ScriptState* scriptState,
                          const RequestInfo& input,
                          const Dictionary& init,
                          ExceptionState& exceptionState) {
-  ASSERT(!input.isNull());
+  DCHECK(!input.isNull());
   if (input.isUSVString())
     return create(scriptState, input.getAsUSVString(), init, exceptionState);
   return create(scriptState, input.getAsRequest(), init, exceptionState);
 }
 
 Request* Request::create(ScriptState* scriptState,
                          const String& input,
                          ExceptionState& exceptionState) {
   return create(scriptState, input, Dictionary(), exceptionState);
 }
@@ skipping 130 matching lines @@
       return "xslt";
   }
   ASSERT_NOT_REACHED();
   return "";
 }
 
 String Request::referrer() const {
   // "The referrer attribute's getter must return the empty string if
   // request's referrer is no referrer, "about:client" if request's referrer
   // is client and request's referrer, serialized, otherwise."
-  ASSERT(FetchRequestData::noReferrerString() == AtomicString());
-  ASSERT(FetchRequestData::clientReferrerString() ==
+  DCHECK(FetchRequestData::noReferrerString() == AtomicString());

[tkent, 2017/04/08 02:29:54]

Use DCHECK_EQ if it doesn't cause a build failure.

+  DCHECK(FetchRequestData::clientReferrerString() ==

[tkent, 2017/04/08 02:29:54]

Use DCHECK_EQ if it doesn't cause a build failure.

          AtomicString("about:client"));
   return m_request->referrerString();
 }
 
 String Request::getReferrerPolicy() const {
   switch (m_request->getReferrerPolicy()) {
     case ReferrerPolicyAlways:
       return "unsafe-url";
     case ReferrerPolicyDefault:
       return "";
     case ReferrerPolicyNoReferrerWhenDowngrade:
       return "no-referrer-when-downgrade";
     case ReferrerPolicyNever:
       return "no-referrer";
     case ReferrerPolicyOrigin:
       return "origin";
     case ReferrerPolicyOriginWhenCrossOrigin:
       return "origin-when-cross-origin";
     case ReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin:
-      ASSERT(RuntimeEnabledFeatures::reducedReferrerGranularityEnabled());
+      DCHECK(RuntimeEnabledFeatures::reducedReferrerGranularityEnabled());
       return "no-referrer-when-downgrade-origin-when-cross-origin";
   }
   ASSERT_NOT_REACHED();
   return String();
 }
 
 String Request::mode() const {
   // "The mode attribute's getter must return the value corresponding to the
   // first matching statement, switching on request's mode:"
   switch (m_request->mode()) {
@@ skipping 55 matching lines @@
   }
 
   FetchRequestData* request = m_request->clone(scriptState);
   refreshBody(scriptState);
   Headers* headers = Headers::create(request->headerList());
   headers->setGuard(m_headers->getGuard());
   return new Request(scriptState, request, headers);
 }
 
 FetchRequestData* Request::passRequestData(ScriptState* scriptState) {
-  ASSERT(!bodyUsed());
+  DCHECK(!bodyUsed());
   FetchRequestData* data = m_request->pass(scriptState);
   refreshBody(scriptState);
   // |data|'s buffer('s js wrapper) has no retainer, but it's OK because
   // the only caller is the fetch function and it uses the body buffer
   // immediately.
   return data;
 }
 
 bool Request::hasBody() const {
   return bodyBuffer();
@@ skipping 44 matching lines @@
       .set(request.As<v8::Object>(), bodyBuffer);
 }
 
 DEFINE_TRACE(Request) {
   Body::trace(visitor);
   visitor->trace(m_request);
   visitor->trace(m_headers);
 }
 
 }  // namespace blink