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

extensions/browser/api/cast_channel/logger.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 "extensions/browser/api/cast_channel/logger.h"
 
 #include "base/strings/string_util.h"
 #include "base/time/tick_clock.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/logger_util.h"
 #include "net/base/net_errors.h"
+#include "third_party/zlib/zlib.h"
 
 namespace extensions {
 namespace core_api {
 namespace cast_channel {
 
 using net::IPEndPoint;
 using proto::AggregatedSocketEvent;
 using proto::EventType;
 using proto::Log;
 using proto::SocketEvent;
@@ skipping 28 matching lines @@
     case AuthResult::ERROR_NSS_CANNOT_EXTRACT_PUBLIC_KEY:
       return proto::CHALLENGE_REPLY_ERROR_NSS_CANNOT_EXTRACT_PUBLIC_KEY;
     case AuthResult::ERROR_NSS_SIGNED_BLOBS_MISMATCH:
       return proto::CHALLENGE_REPLY_ERROR_NSS_SIGNED_BLOBS_MISMATCH;
     default:
       NOTREACHED();
       return proto::CHALLENGE_REPLY_ERROR_NONE;
   }
 }
 
+scoped_ptr<char[]> Compress(const std::string& input, size_t* length) {
+  *length = 0;
+  z_stream stream = {0};
+  int result = deflateInit2(&stream,
+                            Z_DEFAULT_COMPRESSION,
+                            Z_DEFLATED,
+                            // 16 is added to produce a gzip header + trailer.
+                            MAX_WBITS + 16,
+                            8,  // memLevel = 8 is default.
+                            Z_DEFAULT_STRATEGY);
+  DCHECK_EQ(Z_OK, result);
+
+  size_t out_size = deflateBound(&stream, input.size());
+  scoped_ptr<char[]> out(new char[out_size]);
+
+  COMPILE_ASSERT(sizeof(uint8) == sizeof(char), uint8_char_different_sizes);
+
+  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(input.data()));
+  stream.avail_in = input.size();
+  stream.next_out = reinterpret_cast<uint8*>(out.get());
+  stream.avail_out = out_size;
+
+  // Do a one-shot compression. This will return Z_STREAM_END only if |output|
+  // is large enough to hold all compressed data.
+  result = deflate(&stream, Z_FINISH);
+
+  bool success = (result == Z_STREAM_END);
+
+  if (!success)
+    VLOG(2) << "deflate() failed. Result: " << result;
+
+  result = deflateEnd(&stream);
+  DCHECK(result == Z_OK || result == Z_DATA_ERROR);
+
+  if (success)
+    *length = out_size - stream.avail_out;
+
+  return out.Pass();
+}
+
 }  // namespace
 
 Logger::AggregatedSocketEventLog::AggregatedSocketEventLog() {
 }
 
 Logger::AggregatedSocketEventLog::~AggregatedSocketEventLog() {
 }
 
 Logger::Logger(scoped_ptr<base::TickClock> clock,
                base::TimeTicks unix_epoch_time_ticks)
@@ skipping 127 matching lines @@
       ChallegeReplyErrorToProto(auth_result.error_type));
   if (auth_result.nss_error_code != 0)
     event.set_nss_error_code(auth_result.nss_error_code);
 
   LogSocketEvent(channel_id, event);
 }
 
 SocketEvent Logger::CreateEvent(EventType event_type) {
   SocketEvent event;
   event.set_type(event_type);
-  event.set_timestamp_micros(clock_->NowTicks().ToInternalValue() +
+  event.set_timestamp_micros(clock_->NowTicks().ToInternalValue() -
                              unix_epoch_time_ticks_.ToInternalValue());
   return event;
 }
 
 void Logger::LogSocketEvent(int channel_id, const SocketEvent& socket_event) {
   AggregatedSocketEventLogMap::iterator it =
       aggregated_socket_events_.find(channel_id);
   if (it == aggregated_socket_events_.end()) {
     if (aggregated_socket_events_.size() >= kMaxSocketsToLog) {
       AggregatedSocketEventLogMap::iterator erase_it =
@@ skipping 25 matching lines @@
     it->second->last_errors.net_return_value = socket_event.net_return_value();
   }
   if (socket_event.has_challenge_reply_error_type()) {
     it->second->last_errors.challenge_reply_error_type =
         socket_event.challenge_reply_error_type();
   }
   if (socket_event.has_nss_error_code())
     it->second->last_errors.nss_error_code = socket_event.nss_error_code();
 }
 
-bool Logger::LogToString(std::string* output) const {
-  output->clear();
+scoped_ptr<char[]> Logger::GetLogs(size_t* length) const {
+  *length = 0;
 
   Log log;
   log.set_num_evicted_aggregated_socket_events(
       num_evicted_aggregated_socket_events_);
   log.set_num_evicted_socket_events(num_evicted_socket_events_);
 
   for (AggregatedSocketEventLogMap::const_iterator it =
            aggregated_socket_events_.begin();
        it != aggregated_socket_events_.end();
        ++it) {
     AggregatedSocketEvent* new_aggregated_socket_event =
         log.add_aggregated_socket_event();
     new_aggregated_socket_event->CopyFrom(it->second->aggregated_socket_event);
 
     const std::deque<SocketEvent>& socket_events = it->second->socket_events;
     for (std::deque<SocketEvent>::const_iterator socket_event_it =
              socket_events.begin();
          socket_event_it != socket_events.end();
          ++socket_event_it) {
       SocketEvent* socket_event =
           new_aggregated_socket_event->add_socket_event();
       socket_event->CopyFrom(*socket_event_it);
     }
   }
 
-  return log.SerializeToString(output);
+  std::string serialized;
+  if (!log.SerializeToString(&serialized)) {
+    VLOG(2) << "Failed to serialized proto to string.";
+    return scoped_ptr<char[]>();
+  }
+
+  return Compress(serialized, length);
 }
 
 void Logger::Reset() {
   aggregated_socket_events_.clear();
   num_evicted_aggregated_socket_events_ = 0;
   num_evicted_socket_events_ = 0;
 }
 
 LastErrors Logger::GetLastErrors(int channel_id) const {
   AggregatedSocketEventLogMap::const_iterator it =
       aggregated_socket_events_.find(channel_id);
   if (it != aggregated_socket_events_.end()) {
     return it->second->last_errors;
   } else {
     return LastErrors();
   }
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions