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

chrome/common/extensions/extension.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.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 264 matching lines @@
   // deterministicly choose a location.
   CHECK(loc1_rank != loc2_rank);
 
   // Highest rank has highest priority.
   return (loc1_rank > loc2_rank ? loc1 : loc2 );
 }
 
 void Extension::OverrideLaunchUrl(const GURL& override_url) {
   GURL new_url(override_url);
   if (!new_url.is_valid()) {
-    LOG(WARNING) << "Invalid override url given for " << name();
+    DLOG(WARNING) << "Invalid override url given for " << name();
   } else {
     if (new_url.has_port()) {
-      LOG(WARNING) << "Override URL passed for " << name()
-                   << " should not contain a port.  Removing it.";
+      DLOG(WARNING) << "Override URL passed for " << name()
+                    << " should not contain a port.  Removing it.";
 
       GURL::Replacements remove_port;
       remove_port.ClearPort();
       new_url = new_url.ReplaceComponents(remove_port);
     }
 
     launch_web_url_ = new_url.spec();
 
     URLPattern pattern(kValidWebExtentSchemes);
     pattern.Parse(new_url.spec(), URLPattern::ERROR_ON_PORTS);
@@ skipping 73 matching lines @@
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK_EQ("/", extension_url.path());
 
   GURL ret_val = GURL(extension_url.spec() + relative_path);
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
 bool Extension::GenerateId(const std::string& input, std::string* output) {
-  CHECK(output);
+  DCHECK(output);
   uint8 hash[Extension::kIdSize];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   *output = StringToLowerASCII(base::HexEncode(hash, sizeof(hash)));
   ConvertHexadecimalToIDAlphabet(output);
 
   return true;
 }
 
 // Helper method that loads a UserScript object from a dictionary in the
 // content_script list of the manifest.
@@ skipping 758 matching lines @@
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidIsolationValue,
           base::UintToString(i));
       return false;
     }
 
     // Check for isolated storage.
     if (isolation_string == values::kIsolatedStorage) {
       is_storage_isolated_ = true;
     } else {
-      LOG(WARNING) << "Did not recognize isolation type: "
-                   << isolation_string;
+      DLOG(WARNING) << "Did not recognize isolation type: "
+                    << isolation_string;
     }
   }
   return true;
 }
 
 bool Extension::LoadWebIntents(const base::DictionaryValue& manifest,
                                std::string* error) {
   DCHECK(error);
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableWebIntents))
@@ skipping 153 matching lines @@
 
     working = working.substr(start_pos, end_pos - start_pos);
     if (working.length() == 0)
       return false;
   }
 
   return base::Base64Decode(working, output);
 }
 
 bool Extension::ProducePEM(const std::string& input, std::string* output) {
-  CHECK(output);
+  DCHECK(output);
   if (input.length() == 0)
     return false;
 
   return base::Base64Encode(input, output);
 }
 
 bool Extension::FormatPEMForFileOutput(const std::string& input,
                                        std::string* output,
                                        bool is_public) {
-  CHECK(output);
+  DCHECK(output);
   if (input.length() == 0)
     return false;
   *output = "";
   output->append(kKeyBeginHeaderMarker);
   output->append(" ");
   output->append(is_public ? kPublic : kPrivate);
   output->append(" ");
   output->append(kKeyInfoEndMarker);
   output->append("\n");
   for (size_t i = 0; i < input.length(); ) {
@@ skipping 23 matching lines @@
 
 // static
 void Extension::DecodeIconFromPath(const FilePath& icon_path,
                                    Icons icon_size,
                                    scoped_ptr<SkBitmap>* result) {
   if (icon_path.empty())
     return;
 
   std::string file_contents;
   if (!file_util::ReadFileToString(icon_path, &file_contents)) {
-    LOG(ERROR) << "Could not read icon file: " << icon_path.LossyDisplayName();
+    DLOG(ERROR) << "Could not read icon file: " << icon_path.LossyDisplayName();
     return;
   }
 
   // Decode the image using WebKit's image decoder.
   const unsigned char* data =
     reinterpret_cast<const unsigned char*>(file_contents.data());
   webkit_glue::ImageDecoder decoder;
   scoped_ptr<SkBitmap> decoded(new SkBitmap());
   *decoded = decoder.Decode(data, file_contents.length());
   if (decoded->empty()) {
-    LOG(ERROR) << "Could not decode icon file: "
-               << icon_path.LossyDisplayName();
+    DLOG(ERROR) << "Could not decode icon file: "
+                << icon_path.LossyDisplayName();
     return;
   }
 
   if (decoded->width() != icon_size || decoded->height() != icon_size) {
-    LOG(ERROR) << "Icon file has unexpected size: "
-               << base::IntToString(decoded->width()) << "x"
-               << base::IntToString(decoded->height());
+    DLOG(ERROR) << "Icon file has unexpected size: "
+                << base::IntToString(decoded->width()) << "x"
+                << base::IntToString(decoded->height());
     return;
   }
 
   result->swap(decoded);
 }
 
 // static
 const SkBitmap& Extension::GetDefaultIcon(bool is_app) {
   if (is_app) {
     return *ResourceBundle::GetSharedInstance().GetBitmapNamed(
@@ skipping 1567 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}