sync/engine/traffic_recorder.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sync/engine/traffic_recorder.h"
   6
   7 #include "base/json/json_writer.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/values.h"
  11 #include "sync/protocol/proto_value_conversions.h"
  12 #include "sync/protocol/sync.pb.h"
  13 #include "sync/sessions/sync_session.h"
  14
  15 namespace syncer {
  16
  17 TrafficRecorder::TrafficRecord::TrafficRecord(const std::string& message,
  18                                               TrafficMessageType message_type,
  19                                               bool truncated) :
  20     message(message),
  21     message_type(message_type),
  22     truncated(truncated) {
  23 }
  24
  25 TrafficRecorder::TrafficRecord::TrafficRecord()
  26     : message_type(UNKNOWN_MESSAGE_TYPE),
  27       truncated(false) {
  28 }
  29
  30 TrafficRecorder::TrafficRecord::~TrafficRecord() {
  31 }
  32
  33 TrafficRecorder::TrafficRecorder(unsigned int max_messages,
  34     unsigned int max_message_size)
  35     : max_messages_(max_messages),
  36       max_message_size_(max_message_size) {
  37 }
  38
  39 TrafficRecorder::~TrafficRecorder() {
  40 }
  41
  42 namespace {
  43 const char* GetMessageTypeString(TrafficRecorder::TrafficMessageType type) {
  44   switch(type) {
  45     case TrafficRecorder::CLIENT_TO_SERVER_MESSAGE:
  46       return "Request";
  47     case TrafficRecorder::CLIENT_TO_SERVER_RESPONSE:
  48       return "Response";
  49     default:
  50       NOTREACHED();
  51       return "";
  52   }
  53 }
  54 }
  55
  56 DictionaryValue* TrafficRecorder::TrafficRecord::ToValue() const {
  57   scoped_ptr<DictionaryValue> value;
  58   if (truncated) {
  59     value.reset(new DictionaryValue());
  60     value->SetString("message_type",
  61                      GetMessageTypeString(message_type));
  62     value->SetBoolean("truncated", true);
  63   } else if (message_type == TrafficRecorder::CLIENT_TO_SERVER_MESSAGE) {
  64     sync_pb::ClientToServerMessage message_proto;
  65     if (message_proto.ParseFromString(message))
  66       value.reset(
  67           ClientToServerMessageToValue(message_proto,
  68                                        false /* include_specifics */));
  69   } else if (message_type == TrafficRecorder::CLIENT_TO_SERVER_RESPONSE) {
  70     sync_pb::ClientToServerResponse message_proto;
  71     if (message_proto.ParseFromString(message))
  72       value.reset(
  73           ClientToServerResponseToValue(message_proto,
  74                                         false /* include_specifics */));
  75   } else {
  76     NOTREACHED();
  77   }
  78
  79   return value.release();
  80 }
  81
  82
  83 ListValue* TrafficRecorder::ToValue() const {
  84   scoped_ptr<ListValue> value(new ListValue());
  85   std::deque<TrafficRecord>::const_iterator it;
  86   for (it = records_.begin(); it != records_.end(); ++it) {
  87     const TrafficRecord& record = *it;
  88     value->Append(record.ToValue());
  89   }
  90
  91   return value.release();
  92 }
  93
  94
  95 void TrafficRecorder::AddTrafficToQueue(TrafficRecord* record) {
  96   records_.resize(records_.size() + 1);
  97   std::swap(records_.back(), *record);
  98
  99   // We might have more records than our limit.
 100   // Maintain the size invariant by deleting items.
 101   while (records_.size() > max_messages_) {
 102     records_.pop_front();
 103   }
 104 }
 105
 106 void TrafficRecorder::StoreProtoInQueue(
 107     const ::google::protobuf::MessageLite& msg,
 108     TrafficMessageType type) {
 109   bool truncated = false;
 110   std::string message;
 111   if (static_cast<unsigned int>(msg.ByteSize()) >= max_message_size_) {
 112     // TODO(lipalani): Trim the specifics to fit in size.
 113     truncated = true;
 114   } else {
 115     msg.SerializeToString(&message);
 116   }
 117
 118   TrafficRecord record(message, type, truncated);
 119   AddTrafficToQueue(&record);
 120 }
 121
 122 void TrafficRecorder::RecordClientToServerMessage(
 123     const sync_pb::ClientToServerMessage& msg) {
 124   StoreProtoInQueue(msg, CLIENT_TO_SERVER_MESSAGE);
 125 }
 126
 127 void TrafficRecorder::RecordClientToServerResponse(
 128     const sync_pb::ClientToServerResponse& response) {
 129   StoreProtoInQueue(response, CLIENT_TO_SERVER_RESPONSE);
 130 }
 131
 132 }  // namespace syncer
 133