Allow multiple logging::LogMessage{Handler,Listener}s

chrome/browser/safe_browsing/safe_browsing_database_unittest.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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <stddef.h>
 
@@ skipping 192 matching lines @@
                                                    const std::string& ip_str,
                                                    size_t prefix_size) {
   const std::string full_hash_str = HashedIpPrefix(ip_str, prefix_size);
   EXPECT_EQ(sizeof(SBFullHash), full_hash_str.size());
   SBFullHash full_hash;
   std::memcpy(&(full_hash.full_hash), full_hash_str.data(), sizeof(SBFullHash));
   return BuildChunk(chunk_number, ChunkData::ADD, ChunkData::FULL_32B,
                     &full_hash, sizeof(full_hash), std::vector<int>());
 }
 
-// Prevent DCHECK from killing tests.
-// TODO(shess): Pawel disputes the use of this, so the test which uses
-// it is DISABLED.  http://crbug.com/56448
-class ScopedLogMessageIgnorer {
- public:
-  ScopedLogMessageIgnorer() {
-    logging::SetLogMessageHandler(&LogMessageIgnorer);
-  }
-  ~ScopedLogMessageIgnorer() {
-    // TODO(shess): Would be better to verify whether anyone else
-    // changed it, and then restore it to the previous value.
-    logging::SetLogMessageHandler(NULL);
-  }
-
- private:
-  static bool LogMessageIgnorer(int severity, const char* file, int line,
-      size_t message_start, const std::string& str) {
-    // Intercept FATAL, strip the stack backtrace, and log it without
-    // the crash part.
-    if (severity == logging::LOG_FATAL) {
-      size_t newline = str.find('\n');
-      if (newline != std::string::npos) {
-        const std::string msg = str.substr(0, newline + 1);
-        fprintf(stderr, "%s", msg.c_str());
-        fflush(stderr);
-      }
-      return true;
-    }
-
-    return false;
-  }
-};
-
 }  // namespace
 
 class SafeBrowsingDatabaseTest : public PlatformTest {
  public:
   SafeBrowsingDatabaseTest() : task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
     PlatformTest::SetUp();
 
     // Setup a database in a temporary directory.
@@ skipping 909 matching lines @@
                                 kCacheLifetime);
   }
 
   // The cached response means the collision no longer causes a hit.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }
 
 // Test that corrupt databases are appropriately handled, even if the
 // corruption is detected in the midst of the update.
-// TODO(shess): Disabled until ScopedLogMessageIgnorer resolved.
+// TODO(shess): Disabled until DCHECK killing is resolved.
 // http://crbug.com/56448
 TEST_F(SafeBrowsingDatabaseTest, DISABLED_FileCorruptionHandling) {
   // Re-create the database in a captive message loop so that we can
   // influence task-posting.  Database specifically needs to the
   // file-backed.
   database_.reset();
   base::MessageLoop loop;
   SafeBrowsingStoreFile* store = new SafeBrowsingStoreFile(task_runner_);
   database_.reset(new SafeBrowsingDatabaseNew(
       task_runner_, store, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL));
@@ skipping 14 matching lines @@
   // until the entire table is read in |UpdateFinished()|.
   FILE* fp = base::OpenFile(database_filename_, "r+");
   ASSERT_TRUE(fp);
   ASSERT_NE(-1, fseek(fp, -8, SEEK_END));
   for (size_t i = 0; i < 8; ++i) {
     fputc('!', fp);
   }
   fclose(fp);
 
   {
-    // The following code will cause DCHECKs, so suppress the crashes.
-    ScopedLogMessageIgnorer ignorer;
+    // The following code will cause DCHECKs.
+    // There's no way to prevent DCHECK from killing tests.
+    // TODO(shess): Pawel disputes the use of using (removed) LogMessageHandler
+    // to hijack the message, so this test is DISABLED.  http://crbug.com/56448
 
     // Start an update.  The insert will fail due to corruption.
     ASSERT_TRUE(database_->UpdateStarted(&lists));
     database_->InsertChunks(kMalwareList, chunks);
     database_->UpdateFinished(true);
 
     // Database file still exists until the corruption handler has run.
     EXPECT_TRUE(base::PathExists(database_filename_));
 
     // Flush through the corruption-handler task.
@@ skipping 1146 matching lines @@
   ASSERT_EQ(1U, prefix_hits.size());
   EXPECT_EQ(SBPrefixForString(kExampleCollision), prefix_hits[0]);
   EXPECT_TRUE(cache_hits.empty());
 
   // This prefix collides, but no full hash match.
   EXPECT_FALSE(database_->ContainsBrowseUrl(
       GURL(std::string("http://") + kExampleFine), &prefix_hits, &cache_hits));
 }
 
 }  // namespace safe_browsing