Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/win32filesystem.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 58 matching lines @@
   if (fs && !fs->Open(filename.pathname().c_str(), mode.c_str(), NULL)) {
     delete fs;
     fs = NULL;
   }
   return fs;
 }
 
 bool Win32Filesystem::DeleteFile(const Pathname &filename) {
   LOG(LS_INFO) << "Deleting file " << filename.pathname();
   if (!IsFile(filename)) {
-    ASSERT(IsFile(filename));
+    RTC_DCHECK(IsFile(filename));
     return false;
   }
   return ::DeleteFile(ToUtf16(filename.pathname()).c_str()) != 0;
 }
 
 bool Win32Filesystem::DeleteEmptyFolder(const Pathname &folder) {
   LOG(LS_INFO) << "Deleting folder " << folder.pathname();
 
   std::string no_slash(folder.pathname(), 0, folder.pathname().length()-1);
   return ::RemoveDirectory(ToUtf16(no_slash).c_str()) != 0;
 }
 
 bool Win32Filesystem::GetTemporaryFolder(Pathname &pathname, bool create,
                                          const std::string *append) {
   wchar_t buffer[MAX_PATH + 1];
   if (!::GetTempPath(arraysize(buffer), buffer))
     return false;
   if (!IsCurrentProcessLowIntegrity() &&
       !::GetLongPathName(buffer, buffer, arraysize(buffer)))
     return false;
   size_t len = strlen(buffer);
   if ((len > 0) && (buffer[len-1] != '\\')) {
     len += strcpyn(buffer + len, arraysize(buffer) - len, L"\\");
   }
   if (len >= arraysize(buffer) - 1)
     return false;
   pathname.clear();
   pathname.SetFolder(ToUtf8(buffer));
   if (append != NULL) {
-    ASSERT(!append->empty());
+    RTC_DCHECK(!append->empty());
     pathname.AppendFolder(*append);
   }
   return !create || CreateFolder(pathname);
 }
 
 std::string Win32Filesystem::TempFilename(const Pathname &dir,
                                           const std::string &prefix) {
   wchar_t filename[MAX_PATH];
   if (::GetTempFileName(ToUtf16(dir.pathname()).c_str(),
                         ToUtf16(prefix).c_str(), 0, filename) != 0)
     return ToUtf8(filename);
   RTC_NOTREACHED();
   return "";
 }
 
 bool Win32Filesystem::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_INFO) << "Moving " << old_path.pathname()
                << " to " << new_path.pathname();
   return ::MoveFile(ToUtf16(old_path.pathname()).c_str(),
                     ToUtf16(new_path.pathname()).c_str()) != 0;
 }
 
 bool Win32Filesystem::IsFolder(const Pathname &path) {
   WIN32_FILE_ATTRIBUTE_DATA data = {0};
@@ skipping 71 matching lines @@
 
 bool Win32Filesystem::GetAppPathname(Pathname* path) {
   TCHAR buffer[MAX_PATH + 1];
   if (0 == ::GetModuleFileName(NULL, buffer, arraysize(buffer)))
     return false;
   path->SetPathname(ToUtf8(buffer));
   return true;
 }
 
 bool Win32Filesystem::GetAppDataFolder(Pathname* path, bool per_user) {
-  ASSERT(!organization_name_.empty());
-  ASSERT(!application_name_.empty());
+  RTC_DCHECK(!organization_name_.empty());
+  RTC_DCHECK(!application_name_.empty());
   TCHAR buffer[MAX_PATH + 1];
   int csidl = per_user ? CSIDL_LOCAL_APPDATA : CSIDL_COMMON_APPDATA;
   if (!::SHGetSpecialFolderPath(NULL, buffer, csidl, TRUE))
     return false;
   if (!IsCurrentProcessLowIntegrity() &&
       !::GetLongPathName(buffer, buffer, arraysize(buffer)))
     return false;
   size_t len = strcatn(buffer, arraysize(buffer), __T("\\"));
   len += strcpyn(buffer + len, arraysize(buffer) - len,
                  ToUtf16(organization_name_).c_str());
@@ skipping 43 matching lines @@
   UINT drive_type = ::GetDriveType(target_drive);
   if ((drive_type == DRIVE_REMOTE) || (drive_type == DRIVE_UNKNOWN)) {
     LOG(LS_VERBOSE) << "Remote or unknown drive: " << drive;
     return false;
   }
 
   int64_t total_number_of_bytes;       // receives the number of bytes on disk
   int64_t total_number_of_free_bytes;  // receives the free bytes on disk
   // make sure things won't change in 64 bit machine
   // TODO replace with compile time assert
-  ASSERT(sizeof(ULARGE_INTEGER) == sizeof(uint64_t));  // NOLINT
+  RTC_DCHECK(sizeof(ULARGE_INTEGER) == sizeof(uint64_t));  // NOLINT
   if (::GetDiskFreeSpaceEx(target_drive,
                            (PULARGE_INTEGER)free_bytes,
                            (PULARGE_INTEGER)&total_number_of_bytes,
                            (PULARGE_INTEGER)&total_number_of_free_bytes)) {
     return true;
   } else {
     LOG(LS_VERBOSE) << "GetDiskFreeSpaceEx returns error.";
     return false;
   }
 }
 
 }  // namespace rtc