Revert of Make LogMessage() handle strings with null bytes

base/logging.cc

 // Copyright (c) 2012 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/logging.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #include <windows.h>
 typedef HANDLE FileHandle;
@@ skipping 591 matching lines @@
       case LOG_ERROR:
       case LOG_ERROR_REPORT:
         priority = ANDROID_LOG_ERROR;
         break;
       case LOG_FATAL:
         priority = ANDROID_LOG_FATAL;
         break;
     }
     __android_log_write(priority, "chromium", str_newline.c_str());
 #endif
-    fwrite(str_newline.data(), str_newline.size(), 1, stderr);
+    fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   } else if (severity_ >= kAlwaysPrintErrorLevel) {
     // When we're only outputting to a log file, above a certain log level, we
     // should still output to stderr so that we can better detect and diagnose
     // problems with unit tests, especially on the buildbots.
-    fwrite(str_newline.data(), str_newline.size(), 1, stderr);
+    fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   }
 
   // write to log file
   if ((logging_destination & LOG_TO_FILE) != 0) {
     // We can have multiple threads and/or processes, so try to prevent them
     // from clobbering each other's writes.
     // If the client app did not call InitLogging, and the lock has not
     // been created do it now. We do this on demand, but if two threads try
     // to do this at the same time, there will be a race condition to create
     // the lock. This is why InitLogging should be called from the main
     // thread at the beginning of execution.
     LoggingLock::Init(LOCK_LOG_FILE, NULL);
     LoggingLock logging_lock;
     if (InitializeLogFileHandle()) {
 #if defined(OS_WIN)
       SetFilePointer(log_file, 0, 0, SEEK_END);
       DWORD num_written;
       WriteFile(log_file,
                 static_cast<const void*>(str_newline.c_str()),
                 static_cast<DWORD>(str_newline.length()),
                 &num_written,
                 NULL);
 #else
-      fwrite(str_newline.data(), str_newline.size(), 1, log_file);
+      fprintf(log_file, "%s", str_newline.c_str());
       fflush(log_file);
 #endif
     }
   }
 
   if (severity_ == LOG_FATAL) {
     // Ensure the first characters of the string are on the stack so they
     // are contained in minidumps for diagnostic purposes.
     char str_stack[1024];
     str_newline.copy(str_stack, arraysize(str_stack));
@@ skipping 210 matching lines @@
     return *log_file_name;
   return std::wstring();
 }
 #endif
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << base::WideToUTF8(std::wstring(wstr));
 }