Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/exported

third_party/WebKit/Source/platform/exported/WebFileSystemCallbacks.cpp

 /*
  * Copyright (C) 2013 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 57 matching lines @@
 
 void WebFileSystemCallbacks::Reset() {
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::Assign(const WebFileSystemCallbacks& other) {
   private_ = other.private_;
 }
 
 void WebFileSystemCallbacks::DidSucceed() {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   private_->Callbacks()->DidSucceed();
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidReadMetadata(const WebFileInfo& web_file_info) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   FileMetadata file_metadata;
   file_metadata.modification_time = web_file_info.modification_time;
   file_metadata.length = web_file_info.length;
   file_metadata.type = static_cast<FileMetadata::Type>(web_file_info.type);
   file_metadata.platform_path = web_file_info.platform_path;
   private_->Callbacks()->DidReadMetadata(file_metadata);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidCreateSnapshotFile(
     const WebFileInfo& web_file_info) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   // It's important to create a BlobDataHandle that refers to the platform file
   // path prior to return from this method so the underlying file will not be
   // deleted.
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
   blob_data->AppendFile(web_file_info.platform_path, 0, web_file_info.length,
                         InvalidFileTime());
   RefPtr<BlobDataHandle> snapshot_blob =
       BlobDataHandle::Create(std::move(blob_data), web_file_info.length);
 
   FileMetadata file_metadata;
   file_metadata.modification_time = web_file_info.modification_time;
   file_metadata.length = web_file_info.length;
   file_metadata.type = static_cast<FileMetadata::Type>(web_file_info.type);
   file_metadata.platform_path = web_file_info.platform_path;
   private_->Callbacks()->DidCreateSnapshotFile(file_metadata, snapshot_blob);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidReadDirectory(
     const WebVector<WebFileSystemEntry>& entries,
     bool has_more) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   for (size_t i = 0; i < entries.size(); ++i)
     private_->Callbacks()->DidReadDirectoryEntry(entries[i].name,
                                                  entries[i].is_directory);
   private_->Callbacks()->DidReadDirectoryEntries(has_more);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidOpenFileSystem(const WebString& name,
                                                const WebURL& root_url) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   private_->Callbacks()->DidOpenFileSystem(name, root_url);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidResolveURL(const WebString& name,
                                            const WebURL& root_url,
                                            WebFileSystemType type,
                                            const WebString& file_path,
                                            bool is_directory) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   private_->Callbacks()->DidResolveURL(name, root_url,
                                        static_cast<FileSystemType>(type),
                                        file_path, is_directory);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidCreateFileWriter(WebFileWriter* web_file_writer,
                                                  long long length) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   private_->Callbacks()->DidCreateFileWriter(WTF::WrapUnique(web_file_writer),
                                              length);
   private_.Reset();
 }
 
 void WebFileSystemCallbacks::DidFail(WebFileError error) {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   private_->Callbacks()->DidFail(error);
   private_.Reset();
 }
 
 bool WebFileSystemCallbacks::ShouldBlockUntilCompletion() const {
-  ASSERT(!private_.IsNull());
+  DCHECK(!private_.IsNull());
   return private_->Callbacks()->ShouldBlockUntilCompletion();
 }
 
 }  // namespace blink