Replace all EXPECT_DEBUG_DEATH tests with EXPECT_DFATAL in QUIC code.

Switch associated DCHECKS to LOG(DFATAL).

Merge internal change: 60160485

Review URL: https://codereview.chromium.org/146823003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@246971 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 30 insertions, 41 deletions

diff --git a/net/quic/quic_data_writer.cc b/net/quic/quic_data_writer.cc
index b7aff26..70b0fda 100644
--- a/net/quic/quic_data_writer.cc
+++ b/net/quic/quic_data_writer.cc
@@ -167,7 +167,10 @@ void QuicDataWriter::WritePadding() {
 }
 
 bool QuicDataWriter::WriteUInt8ToOffset(uint8 value, size_t offset) {
-  DCHECK_LT(offset, capacity_);
+  if (offset >= capacity_) {
+    LOG(DFATAL) << "offset: " << offset << " >= capacity: " << capacity_;
+    return false;
+  }
   size_t latched_length = length_;
   length_ = offset;
   bool success = WriteUInt8(value);
diff --git a/net/quic/quic_data_writer_test.cc b/net/quic/quic_data_writer_test.cc
index 9106947..e53f1ee0 100644
--- a/net/quic/quic_data_writer_test.cc
+++ b/net/quic/quic_data_writer_test.cc
@@ -6,6 +6,7 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/quic_data_reader.h"
+#include "net/quic/test_tools/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -32,13 +33,8 @@ TEST(QuicDataWriterTest, WriteUInt8ToOffset) {
 TEST(QuicDataWriterDeathTest, WriteUInt8ToOffset) {
   QuicDataWriter writer(4);
 
-#if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST)
-#if !defined(DCHECK_ALWAYS_ON)
-  EXPECT_DEBUG_DEATH(writer.WriteUInt8ToOffset(5, 4), "Check failed");
-#else
-  EXPECT_DEATH(writer.WriteUInt8ToOffset(5, 4), "Check failed");
-#endif
-#endif
+  EXPECT_DFATAL(EXPECT_FALSE(writer.WriteUInt8ToOffset(5, 4)),
+                "offset: 4 >= capacity: 4");
 }
 
 TEST(QuicDataWriterTest, SanityCheckUFloat16Consts) {
diff --git a/net/quic/quic_stream_sequencer.cc b/net/quic/quic_stream_sequencer.cc
index 3e6e317c..8696e7c 100644
--- a/net/quic/quic_stream_sequencer.cc
+++ b/net/quic/quic_stream_sequencer.cc
@@ -42,7 +42,11 @@ QuicStreamSequencer::~QuicStreamSequencer() {
 bool QuicStreamSequencer::WillAcceptStreamFrame(
     const QuicStreamFrame& frame) const {
   size_t data_len = frame.data.TotalBufferSize();
-  DCHECK_LE(data_len, max_frame_memory_);
+  if (data_len > max_frame_memory_) {
+    LOG(DFATAL) << "data_len: " << data_len << " > max_frame_memory_: "
+                << max_frame_memory_;
+    return false;
+  }
 
   if (IsDuplicate(frame)) {
     return true;
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index 7487d58..3fd4c74 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -158,8 +158,8 @@ TEST_F(QuicStreamSequencerTest, RejectOverlyLargeFrame) {
                 "Setting max frame memory to 2.  "
                 "Some frames will be impossible to handle.");
 
-  // TODO(rch): covert this to a DFATAL test.
-  // EXPECT_DEBUG_DEATH(sequencer_->OnFrame(0, "abc"), "");
+  EXPECT_DFATAL(sequencer_->OnFrame(0, "abc"),
+                "data_len: 3 > max_frame_memory_: 2");
 }
 
 TEST_F(QuicStreamSequencerTest, DropFramePastBuffering) {
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index fc11f0b..b9c3a77 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -118,8 +118,15 @@ QuicVersion ReliableQuicStream::version() {
 }
 
 void ReliableQuicStream::WriteOrBufferData(StringPiece data, bool fin) {
-  DCHECK(data.size() > 0 || fin);
-  DCHECK(!fin_buffered_);
+  if (data.empty() && !fin) {
+    LOG(DFATAL) << "data.empty() && !fin";
+    return;
+  }
+
+  if (fin_buffered_) {
+    LOG(DFATAL) << "Fin already buffered";
+    return;
+  }
 
   QuicConsumedData consumed_data(0, false);
   fin_buffered_ = fin;
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index ce352a7..f672bfe 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -11,6 +11,7 @@
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
+#include "net/quic/test_tools/gtest_util.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -134,21 +135,14 @@ TEST_F(ReliableQuicStreamTest, WriteAllData) {
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
 
-// TODO(rtenneti): Death tests crash on OS_ANDROID.
-#if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
 
   // Write no data and no fin.  If we consume nothing we should not be write
   // blocked.
-  EXPECT_DEBUG_DEATH({
-    EXPECT_CALL(*session_, WritevData(kStreamId, _, 1, _, _, _)).WillOnce(
-        Return(QuicConsumedData(0, false)));
-    stream_->WriteOrBufferData(StringPiece(), false);
-    EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
-  }, "");
+  EXPECT_DFATAL(stream_->WriteOrBufferData(StringPiece(), false), "");
+  EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
-#endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG) && !defined(OS_ANDROID)
 
 TEST_F(ReliableQuicStreamTest, BlockIfOnlySomeDataConsumed) {
   Initialize(kShouldProcessData);
diff --git a/net/quic/test_tools/gtest_util.h b/net/quic/test_tools/gtest_util.h
index ff00acd..7622610 100644
--- a/net/quic/test_tools/gtest_util.h
+++ b/net/quic/test_tools/gtest_util.h
@@ -20,8 +20,8 @@ namespace test {
 #define GTEST_DFATAL_(statement, matcher, fail)                         \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                         \
   if (true) {                                                           \
-    ScopedMockLog gtest_log;                                            \
-    ScopedDisableExitOnDFatal gtest_disable_exit;                       \
+    ::net::test::ScopedMockLog gtest_log;                               \
+    ::net::test::ScopedDisableExitOnDFatal gtest_disable_exit;          \
     using ::testing::_;                                                 \
     EXPECT_CALL(gtest_log, Log(_, _, _, _, _))                          \
         .WillRepeatedly(::testing::Return(false));                      \
diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc
index 437aa991..55ec185 100644
--- a/net/tools/quic/end_to_end_test.cc
+++ b/net/tools/quic/end_to_end_test.cc
@@ -19,6 +19,7 @@
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_sent_packet_manager.h"
+#include "net/quic/test_tools/gtest_util.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ -609,23 +610,7 @@ TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
   ReliableQuicStreamPeer::SetWriteSideClosed(
       false, client_->GetOrCreateStream());
 
-#if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST)
-#if !defined(DCHECK_ALWAYS_ON)
-  EXPECT_DEBUG_DEATH({
-      client_->SendData("eep", true);
-      client_->WaitForResponse();
-      EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
-    },
-    "Check failed: !fin_buffered_");
-#else
-  EXPECT_DEATH({
-      client_->SendData("eep", true);
-      client_->WaitForResponse();
-      EXPECT_EQ(QUIC_MULTIPLE_TERMINATION_OFFSETS, client_->stream_error());
-    },
-    "Check failed: !fin_buffered_");
-#endif
-#endif
+  EXPECT_DFATAL(client_->SendData("eep", true), "Fin already buffered");
 }
 
 TEST_P(EndToEndTest, Timeout) {