Measuring data use of different ModelTypes in Sync Service.

sync/engine/syncer_unittest.cc

 // Copyright 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "sync/engine/backoff_delay_provider.h"
 #include "sync/engine/get_commit_ids.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/sync_scheduler_impl.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/internal_api/public/base/model_type.h"
@@ skipping 626 matching lines @@
   EXPECT_TRUE(SyncShareNudge());
   {
     // It should have been committed.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_FALSE(entryA.GetIsUnsynced());
   }
 }
 
+// This test is based on SyncerTest.GetCommitIdsFiltersThrottledEntries. After
+// different steps in that test, the progress is verified against expected
+// progress.
+TEST_F(SyncerTest, DataUseHistogramsTest) {
+  base::HistogramTester histogram_tester;
+  const ModelTypeSet throttled_types(BOOKMARKS);
+  sync_pb::EntitySpecifics bookmark_data;
+  AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
+
+  mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
+                                   foreign_cache_guid(), "-1");
+  EXPECT_TRUE(SyncShareNudge());
+  {
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Count", 0);

[sclittle, 2015/08/14 19:10:59]

Instead of ExpectTotalCount, could you use ExpectUniqueSample or
ExpectBucketCount on the BOOKMARKS type or something?

[amohammadkhan, 2015/08/17 17:56:16]

Done.

+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Bytes", 0);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Count", 1);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Bytes", 63);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.ProgressMarker.Bytes", 84);
+    WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
+    MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
+    A.PutIsUnsynced(true);
+    A.PutSpecifics(bookmark_data);
+    A.PutNonUniqueName("bookmark");
+  }
+
+  // Now sync without enabling bookmarks.
+  mock_server_->ExpectGetUpdatesRequestTypes(
+      Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)));
+  ResetSession();
+  syncer_->NormalSyncShare(
+      Difference(context_->GetEnabledTypes(), ModelTypeSet(BOOKMARKS)),
+      &nudge_tracker_, session_.get());
+
+  {
+    // Nothing should have been committed as bookmarks is throttled.
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Count", 0);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Bytes", 0);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Count", 1);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Bytes", 63);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.ProgressMarker.Bytes", 140);
+  }
+
+  // Sync again with bookmarks enabled.
+  mock_server_->ExpectGetUpdatesRequestTypes(context_->GetEnabledTypes());
+  EXPECT_TRUE(SyncShareNudge());
+  {
+    // It should have been committed.
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Count", 1);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Upload.Bytes", 91);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Count", 1);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.Download.Bytes", 63);
+    histogram_tester.ExpectTotalCount("DataUse.Sync.ProgressMarker.Bytes", 224);
+  }
+}
+
 // We use a macro so we can preserve the error location.
 #define VERIFY_ENTRY(id, is_unapplied, is_unsynced, prev_initialized, \
                      parent_id, version, server_version, id_fac, rtrans) \
   do { \
     Entry entryA(rtrans, syncable::GET_BY_ID, id_fac.FromNumber(id)); \
     ASSERT_TRUE(entryA.good()); \
     /* We don't use EXPECT_EQ here because when the left side param is false,
     gcc 4.6 warns about converting 'false' to pointer type for argument 1. */ \
     EXPECT_TRUE(is_unsynced == entryA.GetIsUnsynced()); \
     EXPECT_TRUE(is_unapplied == entryA.GetIsUnappliedUpdate()); \
@@ skipping 4808 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer