Measuring data use of different ModelTypes in Sync Service.

sync/engine/process_updates_util.cc

 // Copyright 2013 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/process_updates_util.h"
 
 #include "base/location.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/internal_api/public/sessions/update_counters.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/util/cryptographer.h"
+#include "sync/util/data_type_histogram.h"
 
 namespace syncer {
 
 using sessions::StatusController;
 
 using syncable::GET_BY_ID;
 
 namespace {
 
 // This function attempts to determine whether or not this update is genuinely
@@ skipping 268 matching lines @@
       counters->num_reflected_updates_received++;
     }
     if ((*update_it)->deleted()) {
       status->increment_num_tombstone_updates_downloaded_by(1);
       counters->num_tombstone_updates_received++;
     }
     VerifyResult verify_result = VerifyUpdate(trans, **update_it, type);
     if (verify_result != VERIFY_SUCCESS && verify_result != VERIFY_UNDELETE)
       continue;
     ProcessUpdate(**update_it, dir->GetCryptographer(trans), trans);
+    if ((*update_it)->ByteSize() > 0) {
+      UMA_HISTOGRAM_SPARSE_SLOWLY_WITH_VALUE("DataUse.Sync.Download.Bytes",
+                                             ModelTypeToHistogramInt(type),
+                                             (*update_it)->ByteSize());
+    }
+    UMA_HISTOGRAM_SPARSE_SLOWLY("DataUse.Sync.Download.Count",
+                                ModelTypeToHistogramInt(type));
   }
 }
 
 void ExpireEntriesByVersion(syncable::Directory* dir,
                             syncable::ModelNeutralWriteTransaction* trans,
                             ModelType type,
                             int64 version_watermark) {
   syncable::Directory::Metahandles handles;
   dir->GetMetaHandlesOfType(trans, type, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
     syncable::ModelNeutralMutableEntry entry(trans, syncable::GET_BY_HANDLE,
                                              handles[i]);
     if (!entry.good() || !entry.GetId().ServerKnows() ||
         entry.GetUniqueServerTag() == ModelTypeToRootTag(type) ||
         entry.GetIsUnappliedUpdate() || entry.GetIsUnsynced() ||
         entry.GetIsDel() || entry.GetServerIsDel() ||
         entry.GetBaseVersion() >= version_watermark) {
       continue;
     }
 
     // Mark entry as unapplied update first to ensure journaling the deletion.
     entry.PutIsUnappliedUpdate(true);
     // Mark entry as deleted by server.
     entry.PutServerIsDel(true);
     entry.PutServerVersion(version_watermark);
   }
 }
 
 }  // namespace syncer