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 "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;
   }
 }
 
+bool Compress(const std::string& input, std::string* output) {
+  output->resize(input.size());
+
+  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);

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

Can this never actually fail?

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

Normally this shouldn't fail, unless there is not enough memory or if the
parameters are invalid.

+
+  stream.next_in = reinterpret_cast<uint8*>(const_cast<char*>(&input[0]));

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

Add a COMPILE_ASSERT that sizeof(uint8) == sizeof(char).

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

input.data()

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

Done.

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

Done.

+  stream.avail_in = input.size();
+  stream.next_out = reinterpret_cast<uint8*>(&(*output)[0]);

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

output->data()

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

Done.

+  stream.avail_out = output->size();
+
+  // Do a one-shot compression. This will return Z_STREAM_END only if |output|
+  // is large enough to hold all compressed data. Otherwise, Z_OK will be
+  // returned (this should happen very rarely and for small inputs) and
+  // |output| will have to be resized.
+  result = deflate(&stream, Z_FINISH);
+
+  if (result == Z_OK) {

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

while (result == Z_OK) {
...
}

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

Removed since we are doing one-shot compression.

+    do {
+      int old_size = output->size();
+      output->resize(old_size + input.size());

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

net::GrowableIOBuffer would be a better abstraction than dealing with
std::string.

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

Removed since we are doing one-shot compression.

+      stream.next_out = reinterpret_cast<uint8*>(&(*output)[old_size]);

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

Is this code cribbed from somewhere else?  I would be surprised if there isn't a
utility function already written for this.

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

There is an utility function close to this in zlib.h, but it outputs in zlib
format instead of gzip. I have not found an utility function that outputs in
gzip format. (There's a net::GzipFilter but is only used privately in the
namespace)

+      stream.avail_out = output->size() - old_size;
+      result = deflate(&stream, Z_FINISH);
+    } while (result == Z_OK);
+  }
+
+  bool success = (result == Z_STREAM_END);
+
+  if (!success)
+    VLOG(2) << "deflate() failed. Result: " << result;

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

return early here?

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

deflateEnd() needs to be called even if deflate() failed.

+
+  result = deflateEnd(&stream);
+  DCHECK(result == Z_OK || result == Z_DATA_ERROR);
+
+  if (success)

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

Do we need to check result here?

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

No. deflateEnd() returns Z_OK if deflate() was successful, Z_DATA_ERROR
otherwise. Checking success is sufficient.

+    output->resize(output->size() - stream.avail_out);
+
+  return success;
+}
+
 }  // namespace
 
 Logger::AggregatedSocketEventLog::AggregatedSocketEventLog() {
 }
 Logger::AggregatedSocketEventLog::~AggregatedSocketEventLog() {
 }
 
 Logger::Logger(scoped_ptr<base::TickClock> clock,
                base::TimeTicks unix_epoch_time_ticks)
     : clock_(clock.Pass()),
@@ skipping 126 matching lines @@
       ChannegeReplyErrorToProto(auth_result.error_type));
   if (auth_result.nss_error_code != 0)
     event.set_return_value(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 41 matching lines @@
     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 false;
+  }
+
+  if (!Compress(serialized, output)) {
+    VLOG(2) << "Failed to compress serialized contents.";
+    return false;
+  }
+
+  return true;
 }
 
 void Logger::Reset() {
   aggregated_socket_events_.clear();
   num_evicted_aggregated_socket_events_ = 0;
   num_evicted_socket_events_ = 0;
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions