Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/filesystem

third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp

 /*
  * Copyright (C) 2010 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 90 matching lines @@
   else if (type == kFileSystemTypeExternal)
     type_string = kExternalPathPrefix;
   else
     return KURL();
 
   String result = "filesystem:" + origin + "/" + type_string + "/";
   return KURL(kParsedURLString, result);
 }
 
 bool DOMFileSystemBase::SupportsToURL() const {
-  ASSERT(IsValidType(type_));
+  DCHECK(IsValidType(type_));
   return type_ != kFileSystemTypeIsolated;
 }
 
 KURL DOMFileSystemBase::CreateFileSystemURL(const EntryBase* entry) const {
   return CreateFileSystemURL(entry->fullPath());
 }
 
 KURL DOMFileSystemBase::CreateFileSystemURL(const String& full_path) const {
-  ASSERT(DOMFilePath::IsAbsolute(full_path));
+  DCHECK(DOMFilePath::IsAbsolute(full_path));
 
   if (GetType() == kFileSystemTypeExternal) {
     // For external filesystem originString could be different from what we have
     // in m_filesystemRootURL.
     StringBuilder result;
     result.Append("filesystem:");
     result.Append(GetSecurityOrigin()->ToString());
     result.Append('/');
     result.Append(kExternalPathPrefix);
     result.Append(filesystem_root_url_.GetPath());
     // Remove the extra leading slash.
     result.Append(EncodeWithURLEscapeSequences(full_path.Substring(1)));
     return KURL(kParsedURLString, result.ToString());
   }
 
   // For regular types we can just append the entry's fullPath to the
   // m_filesystemRootURL that should look like
   // 'filesystem:<origin>/<typePrefix>'.
-  ASSERT(!filesystem_root_url_.IsEmpty());
+  DCHECK(!filesystem_root_url_.IsEmpty());
   KURL url = filesystem_root_url_;
   // Remove the extra leading slash.
   url.SetPath(url.GetPath() +
               EncodeWithURLEscapeSequences(full_path.Substring(1)));
   return url;
 }
 
 bool DOMFileSystemBase::PathToAbsolutePath(FileSystemType type,
                                            const EntryBase* base,
                                            String path,
                                            String& absolute_path) {
-  ASSERT(base);
+  DCHECK(base);
 
   if (!DOMFilePath::IsAbsolute(path))
     path = DOMFilePath::Append(base->fullPath(), path);
   absolute_path = DOMFilePath::RemoveExtraParentReferences(path);
 
   return (type != kFileSystemTypeTemporary &&
           type != kFileSystemTypePersistent) ||
          DOMFilePath::IsValidPath(absolute_path);
 }
 
@@ skipping 58 matching lines @@
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(MetadataCallbacks::Create(
       success_callback, error_callback, context_, this));
   callbacks->SetShouldBlockUntilCompletion(synchronous_type == kSynchronous);
   FileSystem()->ReadMetadata(CreateFileSystemURL(entry), std::move(callbacks));
 }
 
 static bool VerifyAndGetDestinationPathForCopyOrMove(const EntryBase* source,
                                                      EntryBase* parent,
                                                      const String& new_name,
                                                      String& destination_path) {
-  ASSERT(source);
+  DCHECK(source);
 
   if (!parent || !parent->isDirectory())
     return false;
 
   if (!new_name.IsEmpty() && !DOMFilePath::IsValidName(new_name))
     return false;
 
   const bool is_same_file_system =
       (*source->filesystem() == *parent->filesystem());
 
@@ skipping 79 matching lines @@
 
 void DOMFileSystemBase::Remove(const EntryBase* entry,
                                VoidCallback* success_callback,
                                ErrorCallbackBase* error_callback,
                                SynchronousType synchronous_type) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry);
+  DCHECK(entry);
   // We don't allow calling remove() on the root directory.
   if (entry->fullPath() == String(DOMFilePath::kRoot)) {
     ReportError(error_callback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(
       VoidCallbacks::Create(success_callback, error_callback, context_, this));
   callbacks->SetShouldBlockUntilCompletion(synchronous_type == kSynchronous);
 
   FileSystem()->Remove(CreateFileSystemURL(entry), std::move(callbacks));
 }
 
 void DOMFileSystemBase::RemoveRecursively(const EntryBase* entry,
                                           VoidCallback* success_callback,
                                           ErrorCallbackBase* error_callback,
                                           SynchronousType synchronous_type) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry && entry->isDirectory());
+  DCHECK(entry);
+  DCHECK(entry->isDirectory());
   // We don't allow calling remove() on the root directory.
   if (entry->fullPath() == String(DOMFilePath::kRoot)) {
     ReportError(error_callback, FileError::kInvalidModificationErr);
     return;
   }
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(
       VoidCallbacks::Create(success_callback, error_callback, context_, this));
   callbacks->SetShouldBlockUntilCompletion(synchronous_type == kSynchronous);
 
   FileSystem()->RemoveRecursively(CreateFileSystemURL(entry),
                                   std::move(callbacks));
 }
 
 void DOMFileSystemBase::GetParent(const EntryBase* entry,
                                   EntryCallback* success_callback,
                                   ErrorCallbackBase* error_callback) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return;
   }
 
-  ASSERT(entry);
+  DCHECK(entry);
   String path = DOMFilePath::GetDirectory(entry->fullPath());
 
   FileSystem()->DirectoryExists(
       CreateFileSystemURL(path),
       EntryCallbacks::Create(success_callback, error_callback, context_, this,
                              path, true));
 }
 
 void DOMFileSystemBase::GetFile(const EntryBase* entry,
                                 const String& path,
@@ skipping 56 matching lines @@
 int DOMFileSystemBase::ReadDirectory(DirectoryReaderBase* reader,
                                      const String& path,
                                      EntriesCallback* success_callback,
                                      ErrorCallbackBase* error_callback,
                                      SynchronousType synchronous_type) {
   if (!FileSystem()) {
     ReportError(error_callback, FileError::kAbortErr);
     return 0;
   }
 
-  ASSERT(DOMFilePath::IsAbsolute(path));
+  DCHECK(DOMFilePath::IsAbsolute(path));
 
   std::unique_ptr<AsyncFileSystemCallbacks> callbacks(EntriesCallbacks::Create(
       success_callback, error_callback, context_, reader, path));
   callbacks->SetShouldBlockUntilCompletion(synchronous_type == kSynchronous);
 
   return FileSystem()->ReadDirectory(CreateFileSystemURL(path),
                                      std::move(callbacks));
 }
 
 bool DOMFileSystemBase::WaitForAdditionalResult(int callbacks_id) {
   if (!FileSystem())
     return false;
   return FileSystem()->WaitForAdditionalResult(callbacks_id);
 }
 
 }  // namespace blink