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

chrome/common/extensions/extension_file_util.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/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 52 matching lines @@
   for (int i = 0; i < kMaxAttempts; ++i) {
     FilePath candidate = extension_dir.AppendASCII(
         base::StringPrintf("%s_%u", version.c_str(), i));
     if (!file_util::PathExists(candidate)) {
       version_dir = candidate;
       break;
     }
   }
 
   if (version_dir.empty()) {
-    LOG(ERROR) << "Could not find a home for extension " << id << " with "
-               << "version " << version << ".";
+    DLOG(ERROR) << "Could not find a home for extension " << id << " with "
+                << "version " << version << ".";
     return FilePath();
   }
 
   if (!file_util::Move(unpacked_source_dir, version_dir))
     return FilePath();
 
   return version_dir;
 }
 
 void UninstallExtension(const FilePath& extensions_dir,
@@ skipping 222 matching lines @@
   return true;
 }
 
 void GarbageCollectExtensions(
     const FilePath& install_directory,
     const std::map<std::string, FilePath>& extension_paths) {
   // Nothing to clean up if it doesn't exist.
   if (!file_util::DirectoryExists(install_directory))
     return;
 
-  VLOG(1) << "Garbage collecting extensions...";
+  DVLOG(1) << "Garbage collecting extensions...";
   file_util::FileEnumerator enumerator(install_directory,
                                        false,  // Not recursive.
                                        file_util::FileEnumerator::DIRECTORIES);
   FilePath extension_path;
   for (extension_path = enumerator.Next(); !extension_path.value().empty();
        extension_path = enumerator.Next()) {
     std::string extension_id;
 
     FilePath basename = extension_path.BaseName();
     if (IsStringASCII(basename.value())) {
       extension_id = UTF16ToASCII(basename.LossyDisplayName());
       if (!Extension::IdIsValid(extension_id))
         extension_id.clear();
     }
 
     // Delete directories that aren't valid IDs.
     if (extension_id.empty()) {
-      LOG(WARNING) << "Invalid extension ID encountered in extensions "
-                      "directory: " << basename.value();
-      VLOG(1) << "Deleting invalid extension directory "
-              << extension_path.value() << ".";
+      DLOG(WARNING) << "Invalid extension ID encountered in extensions "
+                       "directory: " << basename.value();
+      DVLOG(1) << "Deleting invalid extension directory "
+               << extension_path.value() << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     std::map<std::string, FilePath>::const_iterator iter =
         extension_paths.find(extension_id);
 
     // If there is no entry in the prefs file, just delete the directory and
     // move on. This can legitimately happen when an uninstall does not
     // complete, for example, when a plugin is in use at uninstall time.
     if (iter == extension_paths.end()) {
-      VLOG(1) << "Deleting unreferenced install for directory "
-              << extension_path.LossyDisplayName() << ".";
+      DVLOG(1) << "Deleting unreferenced install for directory "
+               << extension_path.LossyDisplayName() << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     // Clean up old version directories.
     file_util::FileEnumerator versions_enumerator(
         extension_path,
         false,  // Not recursive.
         file_util::FileEnumerator::DIRECTORIES);
     for (FilePath version_dir = versions_enumerator.Next();
          !version_dir.value().empty();
          version_dir = versions_enumerator.Next()) {
       if (version_dir.BaseName() != iter->second.BaseName()) {
-        VLOG(1) << "Deleting old version for directory "
-                << version_dir.LossyDisplayName() << ".";
+        DVLOG(1) << "Deleting old version for directory "
+                 << version_dir.LossyDisplayName() << ".";
         file_util::Delete(version_dir, true);  // Recursive.
       }
     }
   }
 }
 
 ExtensionMessageBundle* LoadExtensionMessageBundle(
     const FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
@@ skipping 262 matching lines @@
     return temp_path;
 
   return FilePath();
 }
 
 void DeleteFile(const FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util