Cast channel: Add cast.channel.getLogs extension API.

extensions/browser/api/cast_channel/logger_unittest.cc

 // Copyright 2014 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/test/simple_test_tick_clock.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/zlib/zlib.h"
 
 namespace extensions {
 namespace core_api {
 namespace cast_channel {
 
 using proto::AggregatedSocketEvent;
 using proto::EventType;
 using proto::Log;
 using proto::SocketEvent;
 
 class CastChannelLoggerTest : public testing::Test {
  public:
   // |logger_| will take ownership of |clock_|.
   CastChannelLoggerTest()
       : clock_(new base::SimpleTestTickClock),
         logger_(new Logger(scoped_ptr<base::TickClock>(clock_),
                            base::TimeTicks())) {}
   virtual ~CastChannelLoggerTest() {}
 
+  bool Uncompress(const std::string& input, std::string* output) {
+    z_stream stream = {0};
+
+    stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(&input[0]));
+    stream.avail_in = input.size();
+    stream.next_out = reinterpret_cast<uint8*>(&(*output)[0]);
+    stream.avail_out = output->size();
+
+    bool success = false;
+    while (stream.avail_in > 0 && stream.avail_out > 0) {
+      // 16 is added to read in gzip format.
+      int result = inflateInit2(&stream, MAX_WBITS + 16);
+      DCHECK_EQ(Z_OK, result);
+
+      result = inflate(&stream, Z_FINISH);
+      success = (result == Z_STREAM_END);
+      if (!success) {
+        DVLOG(2) << "inflate() failed. Result: " << result;
+        break;
+      }
+
+      result = inflateEnd(&stream);
+      DCHECK(result == Z_OK);
+    }
+
+    if (stream.avail_in == 0) {
+      success = true;
+      output->resize(output->size() - stream.avail_out);
+    }
+    return success;
+  }
+
  protected:
   base::SimpleTestTickClock* clock_;
   scoped_refptr<Logger> logger_;
 };
 
 TEST_F(CastChannelLoggerTest, BasicLogging) {
   logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithDetails(
       1, EventType::TCP_SOCKET_CONNECT, "TCP socket");
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEvent(2, EventType::CAST_SOCKET_CREATED);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventWithRv(1, EventType::SSL_SOCKET_CONNECT, -1);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   logger_->LogSocketEventForMessage(
       2, EventType::MESSAGE_ENQUEUED, "foo_namespace", "details");
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   AuthResult auth_result =
       AuthResult::Create("No response", AuthResult::ERROR_NO_RESPONSE);
 
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
   clock_->Advance(base::TimeDelta::FromMicroseconds(1));
 
   auth_result = AuthResult::CreateWithNSSError(
       "Parsing failed", AuthResult::ERROR_NSS_CERT_PARSING_FAILED, 4);
   logger_->LogSocketChallengeReplyEvent(2, auth_result);
 
   std::string output;

[mark a. foltz, 2014/08/11 23:01:44]

Lines 90-101 could be encapsulated in a utility function that returns a
decompressed Log instance from logger_.

Or, add an API to logger_ to get the Log object directly so you don't have to
decompress it for every test case.

[imcheng, 2014/08/12 07:42:10]

Added utility function in this test. Since we don't need to use decompression in
production code.

   bool success = logger_->LogToString(&output);
   ASSERT_TRUE(success);
 
+  // 10kb should be enough for test purposes.
+  std::string uncompressed(10000, 0);
+  success = Uncompress(output, &uncompressed);
+  ASSERT_TRUE(success);
+
   Log log;
-  success = log.ParseFromString(output);
+  success = log.ParseFromString(uncompressed);
   ASSERT_TRUE(success);
 
   ASSERT_EQ(2, log.aggregated_socket_event_size());
   {
     const AggregatedSocketEvent& aggregated_socket_event =
         log.aggregated_socket_event(0);
     EXPECT_EQ(1, aggregated_socket_event.id());
     EXPECT_EQ(3, aggregated_socket_event.socket_event_size());
     {
       const SocketEvent& event = aggregated_socket_event.socket_event(0);
@@ skipping 51 matching lines @@
 
 TEST_F(CastChannelLoggerTest, TooManySockets) {
   for (int i = 0; i < kMaxSocketsToLog + 5; i++) {
     logger_->LogSocketEvent(i, EventType::CAST_SOCKET_CREATED);
   }
 
   std::string output;
   bool success = logger_->LogToString(&output);
   ASSERT_TRUE(success);
 
+  // 10kb should be enough for test purposes.
+  std::string uncompressed(10000, 0);
+  success = Uncompress(output, &uncompressed);
+  ASSERT_TRUE(success);
+
   Log log;
-  success = log.ParseFromString(output);
+  success = log.ParseFromString(uncompressed);
   ASSERT_TRUE(success);
 
   ASSERT_EQ(kMaxSocketsToLog, log.aggregated_socket_event_size());
   EXPECT_EQ(5, log.num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log.num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log.aggregated_socket_event(0);
   EXPECT_EQ(5, aggregated_socket_event.id());
 }
 
 TEST_F(CastChannelLoggerTest, TooManyEvents) {
   for (int i = 0; i < kMaxEventsPerSocket + 5; i++) {
     logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
     clock_->Advance(base::TimeDelta::FromMicroseconds(1));
   }
 
   std::string output;
   bool success = logger_->LogToString(&output);
   ASSERT_TRUE(success);
 
+  // 100kb should be enough for test purposes.
+  std::string uncompressed(100000, 0);
+  success = Uncompress(output, &uncompressed);
+  ASSERT_TRUE(success);
+
   Log log;
-  success = log.ParseFromString(output);
+  success = log.ParseFromString(uncompressed);
   ASSERT_TRUE(success);
 
   ASSERT_EQ(1, log.aggregated_socket_event_size());
   EXPECT_EQ(0, log.num_evicted_aggregated_socket_events());
   EXPECT_EQ(5, log.num_evicted_socket_events());
 
   const AggregatedSocketEvent& aggregated_socket_event =
       log.aggregated_socket_event(0);
   ASSERT_EQ(kMaxEventsPerSocket, aggregated_socket_event.socket_event_size());
   EXPECT_EQ(5, aggregated_socket_event.socket_event(0).timestamp_micros());
 }
 
 TEST_F(CastChannelLoggerTest, Reset) {
   logger_->LogSocketEvent(1, EventType::CAST_SOCKET_CREATED);
 
   std::string output;
   bool success = logger_->LogToString(&output);
   ASSERT_TRUE(success);
 
+  // 10kb should be enough for test purposes.
+  std::string uncompressed(10000, 0);
+  success = Uncompress(output, &uncompressed);
+  ASSERT_TRUE(success);
+
   Log log;
-  success = log.ParseFromString(output);
+  success = log.ParseFromString(uncompressed);
   ASSERT_TRUE(success);
 
   EXPECT_EQ(1, log.aggregated_socket_event_size());
 
   logger_->Reset();
 
   success = logger_->LogToString(&output);
   ASSERT_TRUE(success);
-  success = log.ParseFromString(output);
+  success = Uncompress(output, &uncompressed);
+  ASSERT_TRUE(success);
+  success = log.ParseFromString(uncompressed);
   ASSERT_TRUE(success);
 
   EXPECT_EQ(0, log.aggregated_socket_event_size());
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions