Replace most LOG statements with DLOG statements in base.

base/file_util_win.cc

 // Copyright (c) 2011 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 "base/file_util.h"
 
 #include <windows.h>
 #include <propvarutil.h>
 #include <psapi.h>
 #include <shellapi.h>
@@ skipping 26 matching lines @@
 
 // Helper for NormalizeFilePath(), defined below.
 bool DevicePathToDriveLetterPath(const FilePath& device_path,
                                  FilePath* drive_letter_path) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   // Get the mapping of drive letters to device paths.
   const int kDriveMappingSize = 1024;
   wchar_t drive_mapping[kDriveMappingSize] = {'\0'};
   if (!::GetLogicalDriveStrings(kDriveMappingSize - 1, drive_mapping)) {
-    LOG(ERROR) << "Failed to get drive mapping.";
+    DLOG(ERROR) << "Failed to get drive mapping.";
     return false;
   }
 
   // The drive mapping is a sequence of null terminated strings.
   // The last string is empty.
   wchar_t* drive_map_ptr = drive_mapping;
   wchar_t device_name[MAX_PATH];
   wchar_t drive[] = L" :";
 
   // For each string in the drive mapping, get the junction that links
@@ skipping 538 matching lines @@
   return OpenFile(*path, "wb+");
 }
 
 bool CreateTemporaryFileInDir(const FilePath& dir,
                               FilePath* temp_file) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   wchar_t temp_name[MAX_PATH + 1];
 
   if (!GetTempFileName(dir.value().c_str(), L"", 0, temp_name)) {
-    PLOG(WARNING) << "Failed to get temporary file name in " << dir.value();
+    DPLOG(WARNING) << "Failed to get temporary file name in " << dir.value();
     return false;
   }
 
   DWORD path_len = GetLongPathName(temp_name, temp_name, MAX_PATH);
   if (path_len > MAX_PATH + 1 || path_len == 0) {
-    PLOG(WARNING) << "Failed to get long path name for " << temp_name;
+    DPLOG(WARNING) << "Failed to get long path name for " << temp_name;
     return false;
   }
 
   std::wstring temp_file_str;
   temp_file_str.assign(temp_name, path_len);
   *temp_file = FilePath(temp_file_str);
   return true;
 }
 
 bool CreateTemporaryDirInDir(const FilePath& base_dir,
@@ skipping 37 matching lines @@
 
   // If the path exists, we've succeeded if it's a directory, failed otherwise.
   const wchar_t* full_path_str = full_path.value().c_str();
   DWORD fileattr = ::GetFileAttributes(full_path_str);
   if (fileattr != INVALID_FILE_ATTRIBUTES) {
     if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
       DVLOG(1) << "CreateDirectory(" << full_path_str << "), "
                << "directory already exists.";
       return true;
     }
-    LOG(WARNING) << "CreateDirectory(" << full_path_str << "), "
-                 << "conflicts with existing file.";
+    DLOG(WARNING) << "CreateDirectory(" << full_path_str << "), "
+                  << "conflicts with existing file.";
     return false;
   }
 
   // Invariant:  Path does not exist as file or directory.
 
   // Attempt to create the parent recursively.  This will immediately return
   // true if it already exists, otherwise will create all required parent
   // directories starting with the highest-level missing parent.
   FilePath parent_path(full_path.DirName());
   if (parent_path.value() == full_path.value()) {
     return false;
   }
   if (!CreateDirectory(parent_path)) {
     DLOG(WARNING) << "Failed to create one of the parent directories.";
     return false;
   }
 
   if (!::CreateDirectory(full_path_str, NULL)) {
     DWORD error_code = ::GetLastError();
     if (error_code == ERROR_ALREADY_EXISTS && DirectoryExists(full_path)) {
       // This error code ERROR_ALREADY_EXISTS doesn't indicate whether we
       // were racing with someone creating the same directory, or a file
       // with the same path.  If DirectoryExists() returns true, we lost the
       // race to create the same directory.
       return true;
     } else {
-      LOG(WARNING) << "Failed to create directory " << full_path_str
-                   << ", last error is " << error_code << ".";
+      DLOG(WARNING) << "Failed to create directory " << full_path_str
+                    << ", last error is " << error_code << ".";
       return false;
     }
   } else {
     return true;
   }
 }
 
 // TODO(rkc): Work out if we want to handle NTFS junctions here or not, handle
 // them if we do decide to.
 bool IsLink(const FilePath& file_path) {
@@ skipping 56 matching lines @@
 int WriteFile(const FilePath& filename, const char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
                                           GENERIC_WRITE,
                                           0,
                                           NULL,
                                           CREATE_ALWAYS,
                                           0,
                                           NULL));
   if (!file) {
-    LOG(WARNING) << "CreateFile failed for path " << filename.value()
-                 << " error code=" << GetLastError();
+    DLOG(WARNING) << "CreateFile failed for path " << filename.value()
+                  << " error code=" << GetLastError();
     return -1;
   }
 
   DWORD written;
   BOOL result = ::WriteFile(file, data, size, &written, NULL);
   if (result && static_cast<int>(written) == size)
     return written;
 
   if (!result) {
     // WriteFile failed.
-    LOG(WARNING) << "writing file " << filename.value()
-                 << " failed, error code=" << GetLastError();
+    DLOG(WARNING) << "writing file " << filename.value()
+                  << " failed, error code=" << GetLastError();
   } else {
     // Didn't write all the bytes.
-    LOG(WARNING) << "wrote" << written << " bytes to " <<
-        filename.value() << " expected " << size;
+    DLOG(WARNING) << "wrote" << written << " bytes to "
+                  << filename.value() << " expected " << size;
   }
   return -1;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(FilePath* dir) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   wchar_t system_buffer[MAX_PATH];
   system_buffer[0] = 0;
@@ skipping 156 matching lines @@
 }
 
 bool MemoryMappedFile::InitializeAsImageSection(const FilePath& file_name) {
   if (IsValid())
     return false;
   file_ = base::CreatePlatformFile(
       file_name, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
       NULL, NULL);
 
   if (file_ == base::kInvalidPlatformFileValue) {
-    LOG(ERROR) << "Couldn't open " << file_name.value();
+    DLOG(ERROR) << "Couldn't open " << file_name.value();
     return false;
   }
 
   if (!MapFileToMemoryInternalEx(SEC_IMAGE)) {
     CloseHandles();
     return false;
   }
 
   return true;
 }
@@ skipping 179 matching lines @@
       uint8 unused = *(touch + offset);
       offset += step_size;
     }
     FreeLibrary(dll_module);
   }
 
   return true;
 }
 
 }  // namespace file_util