Reducing the debug output spam.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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 "net/spdy/spdy_network_transaction.h"
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "net/base/completion_callback.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "testing/platform_test.h"
 
+#define NET_TRACE(level, s)   DLOG(level) << s << __FUNCTION__ << "() "
+
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 // NOTE: In GCC, on a Mac, this can't be in an anonymous namespace!
 // This struct holds information used to construct spdy control and data frames.
 struct SpdyHeaderInfo {
   int kind;
   spdy::SpdyStreamId id;
   spdy::SpdyStreamId assoc_id;
@@ skipping 649 matching lines @@
         ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
     set_connect_data(connect);
   }
 
   virtual MockRead GetNextRead() {
     const MockRead& next_read = StaticSocketDataProvider::PeekRead();
     if (next_read.sequence_number & MockRead::STOPLOOP)
       EndLoop();
     if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
         sequence_number_++) {
-      DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-          << sequence_number_ - 1 << ": Read " << read_index();
+      NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
+          << ": Read " << read_index();
       DumpMockRead(next_read);
       return StaticSocketDataProvider::GetNextRead();
     }
-    DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-        << sequence_number_ - 1 << ": I/O Pending";
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
+        << ": I/O Pending";
     MockRead result = MockRead(true, ERR_IO_PENDING);
     DumpMockRead(result);
     return result;
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
-    DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-        << sequence_number_ << ": Write " << write_index();
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
+        << ": Write " << write_index();
     DumpMockRead(PeekWrite());
     ++sequence_number_;
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
       factory_.NewRunnableMethod(&OrderedSocketData::CompleteRead), 100);
     return StaticSocketDataProvider::OnWrite(data);
   }
 
   virtual void Reset() {
-    DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
+    NET_TRACE(INFO, "  *** ") << "Stage "
         << sequence_number_ << ": Reset()";
     sequence_number_ = 0;
     loop_stop_stage_ = 0;
     set_socket(NULL);
     factory_.RevokeAll();
     StaticSocketDataProvider::Reset();
   }
 
   void SetCompletionCallback(CompletionCallback* callback) {
     callback_ = callback;
   }
 
   // Posts a quit message to the current message loop, if one is running.
   void EndLoop() {
     // If we've already stopped the loop, don't do it again until we've advanced
     // to the next sequence_number.
-    DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-        << sequence_number_ << ": EndLoop()";
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": EndLoop()";
     if (loop_stop_stage_ > 0) {
       const MockRead& next_read = StaticSocketDataProvider::PeekRead();
       if ((next_read.sequence_number & ~MockRead::STOPLOOP) >
           loop_stop_stage_) {
-        DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-            << sequence_number_ << ": Clearing stop index";
+        NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
+            << ": Clearing stop index";
         loop_stop_stage_ = 0;
       } else {
         return;
       }
     }
     // Record the sequence_number at which we stopped the loop.
-    DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-        << sequence_number_ << ": Posting Quit at read " << read_index();
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
+        << ": Posting Quit at read " << read_index();
     loop_stop_stage_ = sequence_number_;
     if (callback_)
       callback_->RunWithParams(Tuple1<int>(ERR_IO_PENDING));
   }
 
   void CompleteRead() {
     if (socket()) {
-      DLOG(INFO) << "  *** " << __FUNCTION__ << "() Stage "
-          << sequence_number_;
+      NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_;
       socket()->OnReadComplete(GetNextRead());
     }
   }
 
  private:
   int sequence_number_;
   int loop_stop_stage_;
   CompletionCallback* callback_;
   ScopedRunnableMethodFactory<OrderedSocketData> factory_;
 };
@@ skipping 1680 matching lines @@
     // We shouldn't get here in this test.
     FAIL() << "Unexpected read: " << rv;
   } while (rv > 0);
 
   // Flush the MessageLoop; this will cause the buffered IO task
   // to run for the final time.
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace net