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

chrome/browser/sync/internal_api/sync_manager.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 "chrome/browser/sync/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 104 matching lines @@
 // because the encryption keys don't match (per chrome instantiation).
 static const int kNigoriOverwriteLimit = 10;
 
 } // namespace
 
 namespace sync_api {
 
 const int SyncManager::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::kPreferencesNudgeDelayMilliseconds = 2000;
 
+// Maximum count and size for traffic recorder.
+const unsigned int kMaxMessagesToRecord = 10;
+const unsigned int kMaxMessageSizeToRecord = 5 * 1024;
+
 //////////////////////////////////////////////////////////////////////////
 // SyncManager's implementation: SyncManager::SyncInternal
 class SyncManager::SyncInternal
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public browser_sync::Cryptographer::Observer,
       public sync_notifier::SyncNotifierObserver,
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
         weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         enable_sync_tabs_for_other_clients_(false),
         registrar_(NULL),
         change_delegate_(NULL),
         initialized_(false),
         testing_mode_(NON_TEST),
         observing_ip_address_changes_(false),
         encryptor_(NULL),
         unrecoverable_error_handler_(NULL),
         report_unrecoverable_error_function_(NULL),
         created_on_loop_(MessageLoop::current()),
-        nigori_overwrite_count_(0) {
+        nigori_overwrite_count_(0),
+        traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord) {
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
           std::make_pair(syncable::ModelTypeFromInt(i), NotificationInfo()));
     }
 
     // Bind message handlers.
     BindJsMessageHandler(
         "getNotificationState",
         &SyncManager::SyncInternal::GetNotificationState);
     BindJsMessageHandler(
         "getNotificationInfo",
         &SyncManager::SyncInternal::GetNotificationInfo);
     BindJsMessageHandler(
         "getRootNodeDetails",
         &SyncManager::SyncInternal::GetRootNodeDetails);
     BindJsMessageHandler(
         "getNodeSummariesById",
         &SyncManager::SyncInternal::GetNodeSummariesById);
     BindJsMessageHandler(
         "getNodeDetailsById",
         &SyncManager::SyncInternal::GetNodeDetailsById);
     BindJsMessageHandler(
         "getChildNodeIds",
         &SyncManager::SyncInternal::GetChildNodeIds);
     BindJsMessageHandler(
         "findNodesContainingString",
         &SyncManager::SyncInternal::FindNodesContainingString);
+    BindJsMessageHandler(
+        "getClientServerTraffic",
+        &SyncManager::SyncInternal::GetClientServerTraffic);
   }
 
   virtual ~SyncInternal() {
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             const WeakHandle<JsEventHandler>& event_handler,
             const std::string& sync_server_and_path,
             int port,
@@ skipping 324 matching lines @@
       const NotificationInfoMap& notification_info);
 
   // JS message handlers.
   JsArgList GetNotificationState(const JsArgList& args);
   JsArgList GetNotificationInfo(const JsArgList& args);
   JsArgList GetRootNodeDetails(const JsArgList& args);
   JsArgList GetNodeSummariesById(const JsArgList& args);
   JsArgList GetNodeDetailsById(const JsArgList& args);
   JsArgList GetChildNodeIds(const JsArgList& args);
   JsArgList FindNodesContainingString(const JsArgList& args);
+  JsArgList GetClientServerTraffic(const JsArgList& args);
 
   FilePath database_path_;
 
   const std::string name_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncInternal> weak_ptr_factory_;
 
   // Thread-safe handle used by
@@ skipping 69 matching lines @@
 
   // These are for interacting with chrome://sync-internals.
   JsMessageHandlerMap js_message_handlers_;
   WeakHandle<JsEventHandler> js_event_handler_;
   JsSyncManagerObserver js_sync_manager_observer_;
   JsMutationEventObserver js_mutation_event_observer_;
 
   // This is for keeping track of client events to send to the server.
   DebugInfoEventListener debug_info_event_listener_;
 
+  browser_sync::TrafficRecorder traffic_recorder_;
+
   Encryptor* encryptor_;
   UnrecoverableErrorHandler* unrecoverable_error_handler_;
   ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
 
   MessageLoop* const created_on_loop_;
 
   // The number of times we've automatically (i.e. not via SetPassphrase or
   // conflict resolver) updated the nigori's encryption keys in this chrome
   // instantiation.
   int nigori_overwrite_count_;
@@ skipping 332 matching lines @@
     DVLOG(1) << "Sync is bringing up SyncSessionContext.";
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(&allstatus_);
     listeners.push_back(this);
     SyncSessionContext* context = new SyncSessionContext(
         connection_manager_.get(),
         directory(),
         model_safe_worker_registrar,
         extensions_activity_monitor,
         listeners,
-        &debug_info_event_listener_);
+        &debug_info_event_listener_,
+        &traffic_recorder_);
     context->set_account_name(credentials.email);
     // The SyncScheduler takes ownership of |context|.
     scheduler_.reset(new SyncScheduler(name_, context, new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in) {
     if (scheduler()) {
       scheduler()->Start(
@@ skipping 1225 matching lines @@
 JsArgList SyncManager::SyncInternal::GetRootNodeDetails(
     const JsArgList& args) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode root(&trans);
   root.InitByRootLookup();
   ListValue return_args;
   return_args.Append(root.GetDetailsAsValue());
   return JsArgList(&return_args);
 }
 
+JsArgList SyncManager::SyncInternal::GetClientServerTraffic(
+    const JsArgList& args) {
+  ListValue return_args;
+  ListValue* value = traffic_recorder_.ToValue();
+  if (value != NULL)
+    return_args.Append(value);
+  return JsArgList(&return_args);
+}
+
 namespace {
 
 int64 GetId(const ListValue& ids, int i) {
   std::string id_str;
   if (!ids.GetString(i, &id_str)) {
     return kInvalidId;
   }
   int64 id = kInvalidId;
   if (!base::StringToInt64(id_str, &id)) {
     return kInvalidId;
@@ skipping 323 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api