Reduce the log verbosity in sslstreamadapter_unittest

webrtc/base/sslstreamadapter_unittest.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 95 matching lines @@
     }
 
     return rtc::SR_SUCCESS;
   }
 
   // Catch readability events on in and pass them up.
   void OnEventIn(rtc::StreamInterface* stream, int sig, int err) {
     int mask = (rtc::SE_READ | rtc::SE_CLOSE);
 
     if (sig & mask) {
-      LOG(LS_INFO) << "SSLDummyStreamBase::OnEvent side=" << side_ <<  " sig="
-        << sig << " forwarding upward";
+      LOG(LS_VERBOSE) << "SSLDummyStreamBase::OnEvent side=" << side_
+                      << " sig=" << sig << " forwarding upward";
       PostEvent(sig & mask, 0);
     }
   }
 
   // Catch writeability events on out and pass them up.
   void OnEventOut(rtc::StreamInterface* stream, int sig, int err) {
     if (sig & rtc::SE_WRITE) {
-      LOG(LS_INFO) << "SSLDummyStreamBase::OnEvent side=" << side_ <<  " sig="
-        << sig << " forwarding upward";
+      LOG(LS_VERBOSE) << "SSLDummyStreamBase::OnEvent side=" << side_
+                      << " sig=" << sig << " forwarding upward";
 
       PostEvent(sig & rtc::SE_WRITE, 0);
     }
   }
 
   // Write to the outgoing FifoBuffer
   rtc::StreamResult WriteData(const void* data, size_t data_len,
                               size_t* written, int* error) {
     return out_->Write(data, data_len, written, error);
   }
@@ skipping 170 matching lines @@
     server_params.common_name = "server";
     server_params.not_before = now + not_before;
     server_params.not_after = now + not_after;
     server_identity_ = rtc::SSLIdentity::GenerateForTest(server_params);
 
     client_ssl_->SetIdentity(client_identity_);
     server_ssl_->SetIdentity(server_identity_);
   }
 
   virtual void OnEvent(rtc::StreamInterface *stream, int sig, int err) {
-    LOG(LS_INFO) << "SSLStreamAdapterTestBase::OnEvent sig=" << sig;
+    LOG(LS_VERBOSE) << "SSLStreamAdapterTestBase::OnEvent sig=" << sig;
 
     if (sig & rtc::SE_READ) {
       ReadData(stream);
     }
 
     if ((stream == client_ssl_.get()) && (sig & rtc::SE_WRITE)) {
       WriteData();
     }
   }
 
@@ skipping 131 matching lines @@
       EXPECT_EQ(rtc::SS_CLOSED, client_ssl_->GetState());
       EXPECT_EQ(rtc::SS_CLOSED, server_ssl_->GetState());
     }
   }
 
   rtc::StreamResult DataWritten(SSLDummyStreamBase *from, const void *data,
                                 size_t data_len, size_t *written,
                                 int *error) {
     // Randomly drop loss_ percent of packets
     if (rtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
-      LOG(LS_INFO) << "Randomly dropping packet, size=" << data_len;
+      LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << data_len;
       *written = data_len;
       return rtc::SR_SUCCESS;
     }
     if (dtls_ && (data_len > mtu_)) {
-      LOG(LS_INFO) << "Dropping packet > mtu, size=" << data_len;
+      LOG(LS_VERBOSE) << "Dropping packet > mtu, size=" << data_len;
       *written = data_len;
       return rtc::SR_SUCCESS;
     }
 
     // Optionally damage application data (type 23). Note that we don't damage
     // handshake packets and we damage the last byte to keep the header
     // intact but break the MAC.
     if (damage_ && (*static_cast<const unsigned char *>(data) == 23)) {
       std::vector<char> buf(data_len);
 
-      LOG(LS_INFO) << "Damaging packet";
+      LOG(LS_VERBOSE) << "Damaging packet";
 
       memcpy(&buf[0], data, data_len);
       buf[data_len - 1]++;
 
       return from->WriteData(&buf[0], data_len, written, error);
     }
 
     return from->WriteData(data, data_len, written, error);
   }
 
@@ skipping 203 matching lines @@
         // Unfortunately, errors are the way that the stream adapter
         // signals close in OpenSSL.
         stream->Close();
         return;
       }
 
       if (r == rtc::SR_BLOCK)
         break;
 
       ASSERT_EQ(rtc::SR_SUCCESS, r);
-      LOG(LS_INFO) << "Read " << bread;
+      LOG(LS_VERBOSE) << "Read " << bread;
 
       recv_stream_.Write(buffer, bread, NULL, NULL);
     }
   }
 
  private:
   rtc::FifoBuffer client_buffer_;
   rtc::FifoBuffer server_buffer_;
   rtc::MemoryStream send_stream_;
   rtc::MemoryStream recv_stream_;
@@ skipping 72 matching lines @@
         // Unfortunately, errors are the way that the stream adapter
         // signals close right now
         stream->Close();
         return;
       }
 
       if (r == rtc::SR_BLOCK)
         break;
 
       ASSERT_EQ(rtc::SR_SUCCESS, r);
-      LOG(LS_INFO) << "Read " << bread;
+      LOG(LS_VERBOSE) << "Read " << bread;
 
       // Now parse the datagram
       ASSERT_EQ(packet_size_, bread);
       unsigned char packet_num = buffer[0];
 
       unsigned int rand_state = packet_num;
       for (size_t i = 1; i < packet_size_; i++) {
         // This is a simple LC PRNG.  Keep in synch with identical code above.
         rand_state = (rand_state * 251 + 19937) >> 7;
         ASSERT_EQ(rand_state & 0xff, buffer[i]);
@@ skipping 26 matching lines @@
   BufferQueueStream server_buffer_;
   size_t packet_size_;
   int count_;
   int sent_;
   std::set<int> received_;
 };
 
 
 rtc::StreamResult SSLDummyStreamBase::Write(const void* data, size_t data_len,
                                               size_t* written, int* error) {
-  LOG(LS_INFO) << "Writing to loopback " << data_len;
+  LOG(LS_VERBOSE) << "Writing to loopback " << data_len;
 
   if (first_packet_) {
     first_packet_ = false;
     if (test_base_->GetLoseFirstPacket()) {
       LOG(LS_INFO) << "Losing initial packet of length " << data_len;
       *written = data_len;  // Fake successful writing also to writer.
       return rtc::SR_SUCCESS;
     }
   }
 
@@ skipping 510 matching lines @@
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));
 INSTANTIATE_TEST_CASE_P(
     SSLStreamAdapterTestsDTLS,
     SSLStreamAdapterTestDTLS,
     Combine(Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256)),
             Values(rtc::KeyParams::RSA(1024, 65537),
                    rtc::KeyParams::RSA(1152, 65537),
                    rtc::KeyParams::ECDSA(rtc::EC_NIST_P256))));