crash-reporter: Use standard logging and new libchromeos Process code

kernel_collector.cc

 // Copyright (c) 2010 The Chromium OS 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 "crash-reporter/kernel_collector.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
-#include "crash-reporter/system_logging.h"
 
 const char KernelCollector::kClearingSequence[] = " ";
 static const char kDefaultKernelStackSignature[] =
     "kernel-UnspecifiedStackSignature";
 static const char kKernelExecName[] = "kernel";
 const pid_t kKernelPid = 0;
 static const char kKernelSignatureKey[] = "sig";
 // Byte length of maximum human readable portion of a kernel crash signature.
 static const int kMaxHumanStringLength = 40;
 static const char kPreservedDumpPath[] = "/sys/kernel/debug/preserved/kcrash";
@@ skipping 13 matching lines @@
 }
 
 void KernelCollector::OverridePreservedDumpPath(const FilePath &file_path) {
   preserved_dump_path_ = file_path;
 }
 
 bool KernelCollector::LoadPreservedDump(std::string *contents) {
   // clear contents since ReadFileToString actually appends to the string.
   contents->clear();
   if (!file_util::ReadFileToString(preserved_dump_path_, contents)) {
-    logger_->LogError("Unable to read %s",
-                      preserved_dump_path_.value().c_str());
+    LOG(ERROR) << "Unable to read " << preserved_dump_path_.value();
     return false;
   }
   return true;
 }
 
 bool KernelCollector::Enable() {
   if (!file_util::PathExists(preserved_dump_path_)) {
-    logger_->LogWarning("Kernel does not support crash dumping");
+    LOG(WARNING) << "Kernel does not support crash dumping";
     return false;
   }
 
   // To enable crashes, we will eventually need to set
   // the chnv bit in BIOS, but it does not yet work.
-  logger_->LogInfo("Enabling kernel crash handling");
+  LOG(INFO) << "Enabling kernel crash handling";
   is_enabled_ = true;
   return true;
 }
 
 bool KernelCollector::ClearPreservedDump() {
   // It is necessary to write at least one byte to the kcrash file for
   // the log to actually be cleared.
   if (file_util::WriteFile(
           preserved_dump_path_,
           kClearingSequence,
           strlen(kClearingSequence)) != strlen(kClearingSequence)) {
-    logger_->LogError("Failed to clear kernel crash dump");
+    LOG(ERROR) << "Failed to clear kernel crash dump";
     return false;
   }
-  logger_->LogInfo("Cleared kernel crash diagnostics");
+  LOG(INFO) << "Cleared kernel crash diagnostics";
   return true;
 }
 
 // Hash a string to a number.  We define our own hash function to not
 // be dependent on a C++ library that might change.  This function
 // uses basically the same approach as tr1/functional_hash.h but with
 // a larger prime number (16127 vs 131).
 static unsigned HashString(const std::string &input) {
   unsigned hash = 0;
   for (size_t i = 0; i < input.length(); ++i)
@@ skipping 164 matching lines @@
   if (kernel_dump.empty()) {
     return false;
   }
   std::string signature;
   if (!ComputeKernelStackSignature(kernel_dump, &signature, false)) {
     signature = kDefaultKernelStackSignature;
   }
 
   bool feedback = is_feedback_allowed_function_();
 
-  logger_->LogInfo("Received prior crash notification from "
-                   "kernel (signature %s) (%s)",
-                   signature.c_str(),
-                   feedback ? "handling" : "ignoring - no consent");
+  LOG(INFO) << "Received prior crash notification from "
+            << "kernel (signature " << signature << ") ("
+            << (feedback ? "handling" : "ignoring - no consent") << ")";
 
   if (feedback) {
     count_crash_function_();
 
     if (!GetCreatedCrashDirectoryByEuid(kRootUid,
                                         &root_crash_directory,
                                         NULL)) {
       return true;
     }
 
     std::string dump_basename =
         FormatDumpBasename(kKernelExecName,
                            time(NULL),
                            kKernelPid);
     FilePath kernel_crash_path = root_crash_directory.Append(
         StringPrintf("%s.kcrash", dump_basename.c_str()));
 
     // We must use WriteNewFile instead of file_util::WriteFile as we
     // do not want to write with root access to a symlink that an attacker
     // might have created.
     if (WriteNewFile(kernel_crash_path,
                      kernel_dump.data(),
                      kernel_dump.length()) !=
         static_cast<int>(kernel_dump.length())) {
-      logger_->LogInfo("Failed to write kernel dump to %s",
-                       kernel_crash_path.value().c_str());
+      LOG(INFO) << "Failed to write kernel dump to "
+                << kernel_crash_path.value().c_str();
       return true;
     }
 
     AddCrashMetaData(kKernelSignatureKey, signature);
     WriteCrashMetaData(
         root_crash_directory.Append(
             StringPrintf("%s.meta", dump_basename.c_str())),
         kKernelExecName,
         kernel_crash_path.value());
 
-    logger_->LogInfo("Stored kcrash to %s",
-                     kernel_crash_path.value().c_str());
+    LOG(INFO) << "Stored kcrash to " << kernel_crash_path.value();
   }
   if (!ClearPreservedDump()) {
     return false;
   }
 
   return true;
 }