RELEASE_ASSERT -> CHECK and ASSERT -> DCHECK in web.

third_party/WebKit/Source/web/AssociatedURLLoader.cpp

 /*
  * Copyright (C) 2010, 2011, 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 153 matching lines @@
 }
 
 AssociatedURLLoader::ClientAdapter::ClientAdapter(AssociatedURLLoader* loader, WebURLLoaderClient* client, const WebURLLoaderOptions& options)
     : m_loader(loader)
     , m_client(client)
     , m_options(options)
     , m_errorTimer(this, &ClientAdapter::notifyError)
     , m_enableErrorNotifications(false)
     , m_didFail(false)
 {
-    ASSERT(m_loader);
-    ASSERT(m_client);
+    DCHECK(m_loader);
+    DCHECK(m_client);
 }
 
 void AssociatedURLLoader::ClientAdapter::willFollowRedirect(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 {
     if (!m_client)
         return;
 
     WrappedResourceRequest wrappedNewRequest(newRequest);
     WrappedResourceResponse wrappedRedirectResponse(redirectResponse);
     m_client->willFollowRedirect(m_loader, wrappedNewRequest, wrappedRedirectResponse);
@@ skipping 36 matching lines @@
         return;
 
     m_client->didDownloadData(m_loader, dataLength, -1);
 }
 
 void AssociatedURLLoader::ClientAdapter::didReceiveData(const char* data, unsigned dataLength)
 {
     if (!m_client)
         return;
 
-    RELEASE_ASSERT(dataLength <= static_cast<unsigned>(std::numeric_limits<int>::max()));
+    CHECK_LE(dataLength, static_cast<unsigned>(std::numeric_limits<int>::max()));
 
     m_client->didReceiveData(m_loader, data, dataLength, -1);
 }
 
 void AssociatedURLLoader::ClientAdapter::didReceiveCachedMetadata(const char* data, int dataLength)
 {
     if (!m_client)
         return;
 
     m_client->didReceiveCachedMetadata(m_loader, data, dataLength);
@@ skipping 42 matching lines @@
     ASSERT_UNUSED(timer, timer == &m_errorTimer);
 
     m_client->didFail(m_loader, m_error);
 }
 
 AssociatedURLLoader::AssociatedURLLoader(RawPtr<WebLocalFrameImpl> frameImpl, const WebURLLoaderOptions& options)
     : m_frameImpl(frameImpl)
     , m_options(options)
     , m_client(0)
 {
-    ASSERT(m_frameImpl);
+    DCHECK(m_frameImpl);
 }
 
 AssociatedURLLoader::~AssociatedURLLoader()
 {
     cancel();
 }
 
 #define STATIC_ASSERT_ENUM(a, b)                              \
     static_assert(static_cast<int>(a) == static_cast<int>(b), \
         "mismatching enum: " #a)
 
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::CrossOriginRequestPolicyDeny, DenyCrossOriginRequests);
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl, UseAccessControl);
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::CrossOriginRequestPolicyAllow, AllowCrossOriginRequests);
 
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::ConsiderPreflight, ConsiderPreflight);
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::ForcePreflight, ForcePreflight);
 STATIC_ASSERT_ENUM(WebURLLoaderOptions::PreventPreflight, PreventPreflight);
 
 void AssociatedURLLoader::loadSynchronously(const WebURLRequest& request, WebURLResponse& response, WebURLError& error, WebData& data)
 {
-    ASSERT(0); // Synchronous loading is not supported.
+    DCHECK(0); // Synchronous loading is not supported.
 }
 
 void AssociatedURLLoader::loadAsynchronously(const WebURLRequest& request, WebURLLoaderClient* client)
 {
-    ASSERT(!m_loader);
-    ASSERT(!m_client);
+    DCHECK(!m_loader);
+    DCHECK(!m_client);
 
     m_client = client;
-    ASSERT(m_client);
+    DCHECK(m_client);
 
     bool allowLoad = true;
     WebURLRequest newRequest(request);
     if (m_options.untrustedHTTP) {
         WebString method = newRequest.httpMethod();
         allowLoad = isValidHTTPToken(method) && FetchUtils::isUsefulMethod(method);
         if (allowLoad) {
             newRequest.setHTTPMethod(FetchUtils::normalizeMethod(method));
             HTTPRequestHeaderValidator validator;
             newRequest.visitHTTPHeaderFields(&validator);
@@ skipping 14 matching lines @@
 
         const ResourceRequest& webcoreRequest = newRequest.toResourceRequest();
         if (webcoreRequest.requestContext() == WebURLRequest::RequestContextUnspecified) {
             // FIXME: We load URLs without setting a TargetType (and therefore a request context) in several
             // places in content/ (P2PPortAllocatorSession::AllocateLegacyRelaySession, for example). Remove
             // this once those places are patched up.
             newRequest.setRequestContext(WebURLRequest::RequestContextInternal);
         }
 
         Document* webcoreDocument = m_frameImpl->frame()->document();
-        ASSERT(webcoreDocument);
+        DCHECK(webcoreDocument);
         m_loader = DocumentThreadableLoader::create(*webcoreDocument, m_clientAdapter.get(), options, resourceLoaderOptions);
         m_loader->start(webcoreRequest);
     }
 
     if (!m_loader) {
         // FIXME: return meaningful error codes.
         m_clientAdapter->setDelayedError(ResourceError());
     }
     m_clientAdapter->enableErrorNotifications();
 }
@@ skipping 11 matching lines @@
     if (m_loader)
         m_loader->setDefersLoading(defersLoading);
 }
 
 void AssociatedURLLoader::setLoadingTaskRunner(blink::WebTaskRunner*)
 {
     // TODO(alexclarke): Maybe support this one day if it proves worthwhile.
 }
 
 } // namespace blink