Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/unixfilesystem.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 27 matching lines @@
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 #include <ctype.h>
 #include <algorithm>
 #endif
 
 #if defined(__native_client__) && !defined(__GLIBC__)
 #include <sys/syslimits.h>
 #endif
 
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/stringutils.h"
 
 #if defined(WEBRTC_MAC)
 // Defined in applefilesystem.mm.  No header file to discourage use
 // elsewhere; other places should use GetApp{Data,Temp}Folder() in
 // this file.  Don't copy/paste.  I mean it.
 char* AppleDataDirectory();
@@ skipping 71 matching lines @@
     delete fs;
     fs = NULL;
   }
   return fs;
 }
 
 bool UnixFilesystem::DeleteFile(const Pathname &filename) {
   LOG(LS_INFO) << "Deleting file:" << filename.pathname();
 
   if (!IsFile(filename)) {
-    ASSERT(IsFile(filename));
+    RTC_DCHECK(IsFile(filename));
     return false;
   }
   return ::unlink(filename.pathname().c_str()) == 0;
 }
 
 bool UnixFilesystem::DeleteEmptyFolder(const Pathname &folder) {
   LOG(LS_INFO) << "Deleting folder" << folder.pathname();
 
   if (!IsFolder(folder)) {
-    ASSERT(IsFolder(folder));
+    RTC_DCHECK(IsFolder(folder));
     return false;
   }
   std::string no_slash(folder.pathname(), 0, folder.pathname().length()-1);
   return ::rmdir(no_slash.c_str()) == 0;
 }
 
 bool UnixFilesystem::GetTemporaryFolder(Pathname &pathname, bool create,
                                         const std::string *append) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  ASSERT(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != NULL);
   pathname.SetPathname(provided_app_temp_folder_, "");
 #else
   if (const char* tmpdir = getenv("TMPDIR")) {
     pathname.SetPathname(tmpdir, "");
   } else if (const char* tmp = getenv("TMP")) {
     pathname.SetPathname(tmp, "");
   } else {
 #ifdef P_tmpdir
     pathname.SetPathname(P_tmpdir, "");
 #else  // !P_tmpdir
     pathname.SetPathname("/tmp/", "");
 #endif  // !P_tmpdir
   }
 #endif  // defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
   if (append) {
-    ASSERT(!append->empty());
+    RTC_DCHECK(!append->empty());
     pathname.AppendFolder(*append);
   }
   return !create || CreateFolder(pathname);
 }
 
 std::string UnixFilesystem::TempFilename(const Pathname &dir,
                                          const std::string &prefix) {
   int len = dir.pathname().size() + prefix.size() + 2 + 6;
   char *tempname = new char[len];
 
   snprintf(tempname, len, "%s/%sXXXXXX", dir.pathname().c_str(),
            prefix.c_str());
   int fd = ::mkstemp(tempname);
   if (fd != -1)
     ::close(fd);
   std::string ret(tempname);
   delete[] tempname;
 
   return ret;
 }
 
 bool UnixFilesystem::MoveFile(const Pathname &old_path,
                               const Pathname &new_path) {
   if (!IsFile(old_path)) {
-    ASSERT(IsFile(old_path));
+    RTC_DCHECK(IsFile(old_path));
     return false;
   }
   LOG(LS_VERBOSE) << "Moving " << old_path.pathname()
                   << " to " << new_path.pathname();
   if (rename(old_path.pathname().c_str(), new_path.pathname().c_str()) != 0) {
     if (errno != EXDEV)
       return false;
     if (!CopyFile(old_path, new_path))
       return false;
     if (!DeleteFile(old_path))
@@ skipping 29 matching lines @@
   while (source->Read(buf, sizeof(buf), &len, NULL) == SR_SUCCESS)
     dest->Write(buf, len, NULL, NULL);
 
   delete source;
   delete dest;
   return true;
 }
 
 bool UnixFilesystem::IsTemporaryPath(const Pathname& pathname) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  ASSERT(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != NULL);
 #endif
 
   const char* const kTempPrefixes[] = {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
     provided_app_temp_folder_,
 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
     "/private/tmp/", "/private/var/tmp/", "/private/var/folders/",
 #endif  // WEBRTC_MAC && !defined(WEBRTC_IOS)
 #else
     "/tmp/", "/var/tmp/",
@@ skipping 48 matching lines @@
   default:
     return false;
   }
   return true;
 }
 
 bool UnixFilesystem::GetAppDataFolder(Pathname* path, bool per_user) {
   // On macOS and iOS, there is no requirement that the path contains the
   // organization.
 #if !defined(WEBRTC_MAC)
-  ASSERT(!organization_name_.empty());
+  RTC_DCHECK(!organization_name_.empty());
 #endif
-  ASSERT(!application_name_.empty());
+  RTC_DCHECK(!application_name_.empty());
 
   // First get the base directory for app data.
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  ASSERT(provided_app_data_folder_ != NULL);
+  RTC_DCHECK(provided_app_data_folder_ != NULL);
   path->SetPathname(provided_app_data_folder_, "");
 #elif defined(WEBRTC_LINUX) // && !WEBRTC_MAC && !WEBRTC_ANDROID
   if (per_user) {
     // We follow the recommendations in
     // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
     // It specifies separate directories for data and config files, but
     // GetAppDataFolder() does not distinguish. We just return the config dir
     // path.
     const char* xdg_config_home = getenv("XDG_CONFIG_HOME");
     if (xdg_config_home) {
@@ skipping 46 matching lines @@
   if (0 != ::chmod(path->pathname().c_str(), 0700)) {
     LOG_ERR(LS_ERROR) << "Can't set mode on " << path;
     return false;
   }
 #endif
   return true;
 }
 
 bool UnixFilesystem::GetAppTempFolder(Pathname* path) {
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC)
-  ASSERT(provided_app_temp_folder_ != NULL);
+  RTC_DCHECK(provided_app_temp_folder_ != NULL);
   path->SetPathname(provided_app_temp_folder_);
   return true;
 #else
-  ASSERT(!application_name_.empty());
+  RTC_DCHECK(!application_name_.empty());
   // TODO: Consider whether we are worried about thread safety.
   if (app_temp_path_ != NULL && strlen(app_temp_path_) > 0) {
     path->SetPathname(app_temp_path_);
     return true;
   }
 
   // Create a random directory as /tmp/<appname>-<pid>-<timestamp>
   char buffer[128];
   sprintfn(buffer, arraysize(buffer), "-%d-%d",
            static_cast<int>(getpid()),
            static_cast<int>(time(0)));
   std::string folder(application_name_);
   folder.append(buffer);
   if (!GetTemporaryFolder(*path, true, &folder))
     return false;
 
   delete [] app_temp_path_;
   app_temp_path_ = CopyString(path->pathname());
   // TODO: atexit(DeleteFolderAndContents(app_temp_path_));
   return true;
 #endif
 }
 
 bool UnixFilesystem::GetDiskFreeSpace(const Pathname& path,
                                       int64_t* freebytes) {
 #ifdef __native_client__
   return false;
 #else  // __native_client__
-  ASSERT(NULL != freebytes);
+  RTC_DCHECK(NULL != freebytes);
   // TODO: Consider making relative paths absolute using cwd.
   // TODO: When popping off a symlink, push back on the components of the
   // symlink, so we don't jump out of the target disk inadvertently.
   Pathname existing_path(path.folder(), "");
   while (!existing_path.folder().empty() && IsAbsent(existing_path)) {
     existing_path.SetFolder(existing_path.parent_folder());
   }
 #if defined(WEBRTC_ANDROID)
   struct statfs vfs;
   memset(&vfs, 0, sizeof(vfs));
@@ skipping 29 matching lines @@
 
 }  // namespace rtc
 
 #if defined(__native_client__)
 extern "C" int __attribute__((weak))
 link(const char* oldpath, const char* newpath) {
   errno = EACCES;
   return -1;
 }
 #endif