Convert chrome/common non-debug logs to debug logs.

chrome/common/zip.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 "chrome/common/zip.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_split.h"
@@ skipping 155 matching lines @@
 #endif
 
 #if defined(OS_POSIX)
   std::string src_file_str = src_file.value();
   unzFile zip_file = unzOpen(src_file_str.c_str());
 #elif defined(OS_WIN)
   std::string src_file_str = WideToUTF8(src_file.value());
   unzFile zip_file = unzOpen2(src_file_str.c_str(), &zip_funcs);
 #endif
   if (!zip_file) {
-    LOG(WARNING) << "couldn't create file " << src_file_str;
+    DLOG(WARNING) << "couldn't create file " << src_file_str;
     return false;
   }
   unz_global_info zip_info;
   int err;
   err = unzGetGlobalInfo(zip_file, &zip_info);
   if (err != UNZ_OK) {
-    LOG(WARNING) << "couldn't open zip " << src_file_str;
+    DLOG(WARNING) << "couldn't open zip " << src_file_str;
     return false;
   }
   bool ret = true;
   for (unsigned int i = 0; i < zip_info.number_entry; ++i) {
     if (!ExtractCurrentFile(zip_file, dest_dir)) {
       ret = false;
       break;
     }
 
     if (i + 1 < zip_info.number_entry) {
       err = unzGoToNextFile(zip_file);
       if (err != UNZ_OK) {
-        LOG(WARNING) << "error %d in unzGoToNextFile";
+        DLOG(WARNING) << "error %d in unzGoToNextFile";
         ret = false;
         break;
       }
     }
   }
   unzClose(zip_file);
   return ret;
 }
 
 static bool AddFileToZip(zipFile zip_file, const FilePath& src_dir) {
   net::FileStream stream;
   int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ;
   if (stream.Open(src_dir, flags) != 0) {
-    LOG(ERROR) << "Could not open stream for path "
-               << src_dir.value();
+    DLOG(ERROR) << "Could not open stream for path "
+                << src_dir.value();
     return false;
   }
 
   int num_bytes;
   char buf[kZipBufSize];
   do {
     num_bytes = stream.Read(buf, kZipBufSize, net::CompletionCallback());
     if (num_bytes > 0) {
       if (ZIP_OK != zipWriteInFileInZip(zip_file, buf, num_bytes)) {
-        LOG(ERROR) << "Could not write data to zip for path "
-                   << src_dir.value();
+        DLOG(ERROR) << "Could not write data to zip for path "
+                    << src_dir.value();
         return false;
       }
     }
   } while (num_bytes > 0);
 
   return true;
 }
 
 static bool AddEntryToZip(zipFile zip_file, const FilePath& path,
                           const FilePath& root_path) {
 #if defined(OS_WIN)
   std::string str_path =
       WideToUTF8(path.value().substr(root_path.value().length() + 1));
   ReplaceSubstringsAfterOffset(&str_path, 0u, "\\", "/");
 #else
   std::string str_path = path.value().substr(root_path.value().length() + 1);
 #endif
 
   bool is_directory = file_util::DirectoryExists(path);
   if (is_directory)
     str_path += "/";
 
   if (ZIP_OK != zipOpenNewFileInZip(
       zip_file, str_path.c_str(),
       NULL, NULL, 0u, NULL, 0u, NULL,  // file info, extrafield local, length,
                                        // extrafield global, length, comment
       Z_DEFLATED, Z_DEFAULT_COMPRESSION)) {
-    LOG(ERROR) << "Could not open zip file entry " << str_path;
+    DLOG(ERROR) << "Could not open zip file entry " << str_path;
     return false;
   }
 
   bool success = true;
   if (!is_directory) {
     success = AddFileToZip(zip_file, path);
   }
 
   if (ZIP_OK != zipCloseFileInZip(zip_file)) {
-    LOG(ERROR) << "Could not close zip file entry " << str_path;
+    DLOG(ERROR) << "Could not close zip file entry " << str_path;
     return false;
   }
 
   return success;
 }
 
 bool Zip(const FilePath& src_dir, const FilePath& dest_file,
          const base::Callback<bool(const FilePath&)>& filter_cb) {
   DCHECK(file_util::DirectoryExists(src_dir));
 
 #if defined(OS_WIN)
   zlib_filefunc_def zip_funcs;
   fill_win32_filefunc(&zip_funcs);
   zip_funcs.zopen_file = ZipOpenFunc;
 #endif
 
 #if defined(OS_POSIX)
   std::string dest_file_str = dest_file.value();
   std::string src_dir_str = src_dir.value();
   zipFile zip_file = zipOpen(dest_file_str.c_str(), APPEND_STATUS_CREATE);
 #elif defined(OS_WIN)
   std::string dest_file_str = WideToUTF8(dest_file.value());
   zipFile zip_file = zipOpen2(dest_file_str.c_str(), APPEND_STATUS_CREATE,
                               NULL,  // global comment
                               &zip_funcs);
 #endif
 
   if (!zip_file) {
-    LOG(WARNING) << "couldn't create file " << dest_file_str;
+    DLOG(WARNING) << "couldn't create file " << dest_file_str;
     return false;
   }
 
   bool success = true;
   file_util::FileEnumerator file_enumerator(
       src_dir, true,  // recursive
       static_cast<file_util::FileEnumerator::FileType>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::DIRECTORIES));
   for (FilePath path = file_enumerator.Next(); !path.value().empty();
        path = file_enumerator.Next()) {
     if (!filter_cb.Run(path)) {
       continue;
     }
 
     if (!AddEntryToZip(zip_file, path, src_dir)) {
       success = false;
       return false;
     }
   }
 
   if (ZIP_OK != zipClose(zip_file, NULL)) {  // global comment
-    LOG(ERROR) << "Error closing zip file " << dest_file_str;
+    DLOG(ERROR) << "Error closing zip file " << dest_file_str;
     return false;
   }
 
   return success;
 }
 
 static bool ExcludeNoFilesFilter(const FilePath& file_path) {
   return true;
 }
 
 static bool ExcludeHiddenFilesFilter(const FilePath& file_path) {
   return file_path.BaseName().value()[0] != '.';
 }
 
 bool Zip(const FilePath& src_dir, const FilePath& dest_file,
          bool include_hidden_files) {
   if (include_hidden_files) {
     return Zip(src_dir, dest_file, base::Bind(&ExcludeNoFilesFilter));
   } else {
     return Zip(src_dir, dest_file, base::Bind(&ExcludeHiddenFilesFilter));
   }
 }