[Sync] Display the client server traffic log in about:sync.

sync/engine/traffic_recorder.cc

 // Copyright (c) 2012 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 "sync/engine/traffic_recorder.h"
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/stringprintf.h"
 #include "base/values.h"
 #include "sync/protocol/proto_value_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/sync_session.h"
 
 namespace browser_sync {
 
 TrafficRecorder::TrafficRecord::TrafficRecord(const std::string& message,
                                               TrafficMessageType message_type,
                                               bool truncated) :
@@ skipping 12 matching lines @@
 
 TrafficRecorder::TrafficRecorder(unsigned int max_messages,
     unsigned int max_message_size)
     : max_messages_(max_messages),
       max_message_size_(max_message_size) {
 }
 
 TrafficRecorder::~TrafficRecorder() {
 }
 
+namespace {
+const char* GetMessageTypeString(TrafficRecorder::TrafficMessageType type) {
+  switch(type) {
+    case TrafficRecorder::CLIENT_TO_SERVER_MESSAGE:
+      return "Request";
+    case TrafficRecorder::CLIENT_TO_SERVER_RESPONSE:
+      return "Response";
+  }
+  NOTREACHED();
+  return "";
+}
+}
+
+DictionaryValue* TrafficRecorder::TrafficRecord::ToValue() const {
+  scoped_ptr<DictionaryValue> value;
+  if (truncated) {
+    value.reset(new DictionaryValue());
+    value->SetString("message_type",
+                     GetMessageTypeString(message_type));
+    value->SetBoolean("truncated", true);
+  } else if (message_type == TrafficRecorder::CLIENT_TO_SERVER_MESSAGE) {
+    sync_pb::ClientToServerMessage message_proto;
+    if (message_proto.ParseFromString(message))
+      value.reset(
+          ClientToServerMessageToValue(message_proto,
+                                       false /* include_specifics */));
+  } else if (message_type == TrafficRecorder::CLIENT_TO_SERVER_RESPONSE) {
+    sync_pb::ClientToServerResponse message_proto;
+    if (message_proto.ParseFromString(message))
+      value.reset(
+          ClientToServerResponseToValue(message_proto,
+                                        false /* include_specifics */));
+  } else {
+    NOTREACHED();
+  }
+
+  return value.release();
+}
+
+
+ListValue* TrafficRecorder::ToValue() const {
+  scoped_ptr<ListValue> value(new ListValue());
+  std::deque<TrafficRecord>::const_iterator it;
+  for (it = records_.begin(); it != records_.end(); ++it) {
+    const TrafficRecord& record = *it;
+    value->Append(record.ToValue());
+  }
+
+  return value.release();
+}
+
+
 
 void TrafficRecorder::AddTrafficToQueue(TrafficRecord* record) {
   records_.resize(records_.size() + 1);
   std::swap(records_.back(), *record);
 
   // We might have more records than our limit.
   // Maintain the size invariant by deleting items.
   while (records_.size() > max_messages_) {
     records_.pop_front();
   }
 }
 
 void TrafficRecorder::StoreProtoInQueue(
     const ::google::protobuf::MessageLite& msg,
     TrafficMessageType type) {
   bool truncated = false;
   std::string message;
-  if (static_cast<unsigned int>(msg.ByteSize()) >= max_message_size_) {
+  if ((unsigned int)msg.ByteSize() >= max_message_size_) {

[rlarocque, 2012/03/30 21:01:11]

This line changed a few times throughout the review so I may have missed some of
the comments that led to this.  

The diff from trunk to version 12 of this patch set shows that we're going from
a static_cast<unsigned int>() to a C style cast here.  I thought the usual style
was to use C++ casts?

[lipalani1, 2012/03/30 23:34:05]

Bad merge. It is static_cast after the latest rebase.
On 2012/03/30 21:01:11, rlarocque wrote:

     // TODO(lipalani): Trim the specifics to fit in size.
     truncated = true;
   } else {
     msg.SerializeToString(&message);
   }
 
   TrafficRecord record(message, type, truncated);
   AddTrafficToQueue(&record);
 }
 
 void TrafficRecorder::RecordClientToServerMessage(
     const sync_pb::ClientToServerMessage& msg) {
   StoreProtoInQueue(msg, CLIENT_TO_SERVER_MESSAGE);
 }
 
 void TrafficRecorder::RecordClientToServerResponse(
     const sync_pb::ClientToServerResponse& response) {
   StoreProtoInQueue(response, CLIENT_TO_SERVER_RESPONSE);
 }
-
 }  // namespace browser_sync