Replace ASSERT with DCHECK in modules/

third_party/WebKit/Source/modules/cachestorage/CacheTest.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 <algorithm>
 #include <memory>
 #include <string>
 #include "bindings/core/v8/ExceptionState.h"
@@ skipping 304 matching lines @@
   // correct values being passed.
   class TestFunction : public ScriptFunction {
    public:
     static v8::Local<v8::Function> Create(ScriptState* script_state,
                                           ScriptValue* out_value) {
       TestFunction* self = new TestFunction(script_state, out_value);
       return self->BindToV8Function();
     }
 
     ScriptValue Call(ScriptValue value) override {
-      ASSERT(!value.IsEmpty());
+      DCHECK(!value.IsEmpty());
       *value_ = value;
       return value;
     }
 
    private:
     TestFunction(ScriptState* script_state, ScriptValue* out_value)
         : ScriptFunction(script_state), value_(out_value) {}
 
     ScriptValue* value_;
   };
@@ skipping 14 matching lines @@
   return info;
 }
 
 TEST_F(CacheStorageTest, Basics) {
   ScriptState::Scope scope(GetScriptState());
   NonThrowableExceptionState exception_state;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::Create();
   ErrorWebCacheForTests* test_cache;
   Cache* cache =
       CreateCache(fetcher, test_cache = new NotImplementedErrorCache());
-  ASSERT(cache);
+  DCHECK(cache);
 
   const String url = "http://www.cachetest.org/";
 
   CacheQueryOptions options;
   ScriptPromise match_promise = cache->match(
       GetScriptState(), StringToRequestInfo(url), options, exception_state);
   EXPECT_EQ(kNotImplementedString, GetRejectString(match_promise));
 
   cache = CreateCache(fetcher, test_cache = new ErrorWebCacheForTests(
                                    kWebServiceWorkerCacheErrorNotFound));
@@ skipping 12 matching lines @@
 
 // Tests that arguments are faithfully passed on calls to Cache methods, except
 // for methods which use batch operations, which are tested later.
 TEST_F(CacheStorageTest, BasicArguments) {
   ScriptState::Scope scope(GetScriptState());
   NonThrowableExceptionState exception_state;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::Create();
   ErrorWebCacheForTests* test_cache;
   Cache* cache =
       CreateCache(fetcher, test_cache = new NotImplementedErrorCache());
-  ASSERT(cache);
+  DCHECK(cache);
 
   const String url = "http://www.cache.arguments.test/";
   test_cache->SetExpectedUrl(&url);
 
   WebServiceWorkerCache::QueryParams expected_query_params;
   expected_query_params.ignore_vary = true;
   expected_query_params.cache_name = "this is a cache name";
   test_cache->SetExpectedQueryParams(&expected_query_params);
 
   CacheQueryOptions options;
   options.setIgnoreVary(1);
   options.setCacheName(expected_query_params.cache_name);
 
   Request* request = NewRequestFromUrl(url);
-  ASSERT(request);
+  DCHECK(request);
   ScriptPromise match_result =
       cache->match(GetScriptState(), RequestToRequestInfo(request), options,
                    exception_state);
   EXPECT_EQ("dispatchMatch",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(match_result));
 
   ScriptPromise string_match_result = cache->match(
       GetScriptState(), StringToRequestInfo(url), options, exception_state);
   EXPECT_EQ("dispatchMatch",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(string_match_result));
 
   request = NewRequestFromUrl(url);
-  ASSERT(request);
+  DCHECK(request);
   ScriptPromise match_all_result =
       cache->matchAll(GetScriptState(), RequestToRequestInfo(request), options,
                       exception_state);
   EXPECT_EQ("dispatchMatchAll",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(match_all_result));
 
   ScriptPromise string_match_all_result = cache->matchAll(
       GetScriptState(), StringToRequestInfo(url), options, exception_state);
   EXPECT_EQ("dispatchMatchAll",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(string_match_all_result));
 
   ScriptPromise keys_result1 = cache->keys(GetScriptState(), exception_state);
   EXPECT_EQ("dispatchKeys",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(keys_result1));
 
   request = NewRequestFromUrl(url);
-  ASSERT(request);
+  DCHECK(request);
   ScriptPromise keys_result2 =
       cache->keys(GetScriptState(), RequestToRequestInfo(request), options,
                   exception_state);
   EXPECT_EQ("dispatchKeys",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(keys_result2));
 
   ScriptPromise string_keys_result2 = cache->keys(
       GetScriptState(), StringToRequestInfo(url), options, exception_state);
   EXPECT_EQ("dispatchKeys",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(string_keys_result2));
 }
 
 // Tests that arguments are faithfully passed to API calls that degrade to batch
 // operations.
 TEST_F(CacheStorageTest, BatchOperationArguments) {
   ScriptState::Scope scope(GetScriptState());
   NonThrowableExceptionState exception_state;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::Create();
   ErrorWebCacheForTests* test_cache;
   Cache* cache =
       CreateCache(fetcher, test_cache = new NotImplementedErrorCache());
-  ASSERT(cache);
+  DCHECK(cache);
 
   WebServiceWorkerCache::QueryParams expected_query_params;
   expected_query_params.cache_name = "this is another cache name";
   test_cache->SetExpectedQueryParams(&expected_query_params);
 
   CacheQueryOptions options;
   options.setCacheName(expected_query_params.cache_name);
 
   const String url = "http://batch.operations.test/";
   Request* request = NewRequestFromUrl(url);
-  ASSERT(request);
+  DCHECK(request);
 
   WebServiceWorkerResponse web_response;
   std::vector<KURL> url_list;
   url_list.push_back(KURL(kParsedURLString, url));
   web_response.SetURLList(url_list);
   Response* response = Response::Create(GetScriptState(), web_response);
 
   WebVector<WebServiceWorkerCache::BatchOperation> expected_delete_operations(
       size_t(1));
   {
@@ skipping 24 matching lines @@
   {
     WebServiceWorkerCache::BatchOperation put_operation;
     put_operation.operation_type = WebServiceWorkerCache::kOperationTypePut;
     request->PopulateWebServiceWorkerRequest(put_operation.request);
     response->PopulateWebServiceWorkerResponse(put_operation.response);
     expected_put_operations[0] = put_operation;
   }
   test_cache->SetExpectedBatchOperations(&expected_put_operations);
 
   request = NewRequestFromUrl(url);
-  ASSERT(request);
+  DCHECK(request);
   ScriptPromise put_result = cache->put(
       GetScriptState(), RequestToRequestInfo(request),
       response->clone(GetScriptState(), exception_state), exception_state);
   EXPECT_EQ("dispatchBatch",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, GetRejectString(put_result));
 
   ScriptPromise string_put_result = cache->put(
       GetScriptState(), StringToRequestInfo(url), response, exception_state);
   EXPECT_EQ("dispatchBatch",
@@ skipping 199 matching lines @@
 
   EXPECT_EQ(kNotImplementedString, GetRejectString(add_result));
   EXPECT_EQ(1, fetcher->FetchCount());
   EXPECT_EQ("dispatchBatch",
             test_cache->GetAndClearLastErrorWebCacheMethodCalled());
 }
 
 }  // namespace
 
 }  // namespace blink