sync: Populate debug counters for directory types

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>
@@ skipping 13 matching lines @@
 #include "base/time/time.h"
 #include "build/build_config.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"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
+#include "sync/internal_api/public/sessions/commit_counters.h"
+#include "sync/internal_api/public/sessions/status_counters.h"
+#include "sync/internal_api/public/sessions/update_counters.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/sync_session_context.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/nigori_util.h"
 #include "sync/syncable/syncable_delete_journal.h"
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_util.h"
@@ skipping 27 matching lines @@
 using syncable::CountEntriesWithName;
 using syncable::Directory;
 using syncable::Entry;
 using syncable::GetFirstEntryWithName;
 using syncable::GetOnlyEntryWithName;
 using syncable::Id;
 using syncable::kEncryptedString;
 using syncable::MutableEntry;
 using syncable::WriteTransaction;
 
-using syncable::BASE_VERSION;
 using syncable::CREATE;
 using syncable::GET_BY_HANDLE;
 using syncable::GET_BY_ID;
 using syncable::GET_BY_CLIENT_TAG;
 using syncable::GET_BY_SERVER_TAG;
-using syncable::ID;
-using syncable::IS_DEL;
-using syncable::IS_DIR;
-using syncable::IS_UNAPPLIED_UPDATE;
-using syncable::IS_UNSYNCED;
-using syncable::META_HANDLE;
-using syncable::MTIME;
-using syncable::NON_UNIQUE_NAME;
-using syncable::PARENT_ID;
-using syncable::BASE_SERVER_SPECIFICS;
-using syncable::SERVER_IS_DEL;
-using syncable::SERVER_PARENT_ID;
-using syncable::SERVER_SPECIFICS;
-using syncable::SERVER_VERSION;
-using syncable::UNIQUE_CLIENT_TAG;
-using syncable::UNIQUE_SERVER_TAG;
-using syncable::SPECIFICS;
-using syncable::SYNCING;
 using syncable::UNITTEST;
 
 using sessions::MockDebugInfoGetter;
 using sessions::StatusController;
 using sessions::SyncSessionContext;
 using sessions::SyncSession;
 
+namespace {
+
+// A helper to hold on to the counters emitted by the sync engine.
+class TypeDebugInfoCache : public TypeDebugInfoObserver {
+ public:
+  TypeDebugInfoCache();
+  virtual ~TypeDebugInfoCache();
+
+  CommitCounters GetLatestCommitCounters(ModelType type) const;
+  UpdateCounters GetLatestUpdateCounters(ModelType type) const;
+  StatusCounters GetLatestStatusCounters(ModelType type) const;
+
+  // TypeDebugInfoObserver implementation.
+  virtual void OnCommitCountersUpdated(
+      syncer::ModelType type,
+      const CommitCounters& counters) OVERRIDE;
+  virtual void OnUpdateCountersUpdated(
+      syncer::ModelType type,
+      const UpdateCounters& counters) OVERRIDE;
+  virtual void OnStatusCountersUpdated(
+      syncer::ModelType type,
+      const StatusCounters& counters) OVERRIDE;
+
+ private:
+  std::map<ModelType, CommitCounters> commit_counters_map_;
+  std::map<ModelType, UpdateCounters> update_counters_map_;
+  std::map<ModelType, StatusCounters> status_counters_map_;
+};
+
+TypeDebugInfoCache::TypeDebugInfoCache() {}
+
+TypeDebugInfoCache::~TypeDebugInfoCache() {}
+
+CommitCounters TypeDebugInfoCache::GetLatestCommitCounters(
+    ModelType type) const {
+  std::map<ModelType, CommitCounters>::const_iterator it =
+      commit_counters_map_.find(type);
+  if (it == commit_counters_map_.end()) {
+    return CommitCounters();
+  } else {
+    return it->second;
+  }
+}
+
+UpdateCounters TypeDebugInfoCache::GetLatestUpdateCounters(
+    ModelType type) const {
+  std::map<ModelType, UpdateCounters>::const_iterator it =
+      update_counters_map_.find(type);
+  if (it == update_counters_map_.end()) {
+    return UpdateCounters();
+  } else {
+    return it->second;
+  }
+}
+
+StatusCounters TypeDebugInfoCache::GetLatestStatusCounters(
+    ModelType type) const {
+  std::map<ModelType, StatusCounters>::const_iterator it =
+      status_counters_map_.find(type);
+  if (it == status_counters_map_.end()) {
+    return StatusCounters();
+  } else {
+    return it->second;
+  }
+}
+
+void TypeDebugInfoCache::OnCommitCountersUpdated(
+    syncer::ModelType type,
+    const CommitCounters& counters) {
+  commit_counters_map_[type] = counters;
+}
+
+void TypeDebugInfoCache::OnUpdateCountersUpdated(
+    syncer::ModelType type,
+    const UpdateCounters& counters) {
+  update_counters_map_[type] = counters;
+}
+
+void TypeDebugInfoCache::OnStatusCountersUpdated(
+    syncer::ModelType type,
+    const StatusCounters& counters) {
+  status_counters_map_[type] = counters;
+}
+
+} // namespace
+
 class SyncerTest : public testing::Test,
                    public SyncSession::Delegate,
                    public SyncEngineEventListener {
  protected:
   SyncerTest()
       : extensions_activity_(new ExtensionsActivity),
         syncer_(NULL),
         saw_syncer_event_(false),
         last_client_invalidation_hint_buffer_size_(10) {
 }
@@ skipping 95 matching lines @@
     EnableDatatype(NIGORI);
     workers_.push_back(scoped_refptr<ModelSafeWorker>(
         new FakeModelWorker(GROUP_PASSIVE)));
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     GetModelSafeRoutingInfo(&routing_info);
 
     model_type_registry_.reset(new ModelTypeRegistry(workers_, directory()));
+    model_type_registry_->RegisterDirectoryTypeDebugInfoObserver(
+        &debug_info_cache_);
 
     context_.reset(
         new SyncSessionContext(
             mock_server_.get(), directory(),
             extensions_activity_,
             listeners, debug_info_getter_.get(),
             model_type_registry_.get(),
             true,  // enable keystore encryption
             false,  // force enable pre-commit GU avoidance experiment
             "fake_invalidator_client_id"));
     context_->SetRoutingInfo(routing_info);
     syncer_ = new Syncer(&cancelation_signal_);
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Directory::Metahandles children;
     directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
     ASSERT_EQ(0u, children.size());
     saw_syncer_event_ = false;
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
     child_id_ = ids_.MakeServer("child id");
     directory()->set_store_birthday(mock_server_->store_birthday());
     mock_server_->SetKeystoreKey("encryption_key");
   }
 
   virtual void TearDown() {
+    model_type_registry_->UnregisterDirectoryTypeDebugInfoObserver(
+        &debug_info_cache_);
     mock_server_.reset();
     delete syncer_;
     syncer_ = NULL;
     dir_maker_.TearDown();
   }
+
   void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
     EXPECT_FALSE(entry->GetIsDir());
     EXPECT_FALSE(entry->GetIsDel());
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_bookmark()->set_url("http://demo/");
     specifics.mutable_bookmark()->set_favicon("PNG");
     entry->PutSpecifics(specifics);
     entry->PutIsUnsynced(true);
   }
   void VerifyTestDataInEntry(BaseTransaction* trans, Entry* entry) {
@@ skipping 125 matching lines @@
     ASSERT_TRUE(expected_positions.size() ==
                 mock_server_->committed_ids().size());
     // If this test starts failing, be aware other sort orders could be valid.
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       SCOPED_TRACE(i);
       EXPECT_EQ(1u, expected_positions.count(i));
       EXPECT_EQ(expected_positions[i], mock_server_->committed_ids()[i]);
     }
   }
 
-  const StatusController& status() {
-    return session_->status_controller();
+  CommitCounters GetCommitCounters(ModelType type) {
+    return debug_info_cache_.GetLatestCommitCounters(type);
+  }
+
+  UpdateCounters GetUpdateCounters(ModelType type) {
+    return debug_info_cache_.GetLatestUpdateCounters(type);
+  }
+
+  StatusCounters GetStatusCounters(ModelType type) {
+    return debug_info_cache_.GetLatestStatusCounters(type);
   }
 
   Directory* directory() {
     return dir_maker_.directory();
   }
 
   const std::string local_cache_guid() {
     return directory()->cache_guid();
   }
 
@@ skipping 77 matching lines @@
 
   TestDirectorySetterUpper dir_maker_;
   FakeEncryptor encryptor_;
   scoped_refptr<ExtensionsActivity> extensions_activity_;
   scoped_ptr<MockConnectionManager> mock_server_;
   CancelationSignal cancelation_signal_;
 
   Syncer* syncer_;
 
   scoped_ptr<SyncSession> session_;
+  TypeDebugInfoCache debug_info_cache_;
   scoped_ptr<ModelTypeRegistry> model_type_registry_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_seconds_;
   int last_client_invalidation_hint_buffer_size_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
 
   ModelTypeSet enabled_datatypes_;
@@ skipping 364 matching lines @@
     VERIFY_ENTRY(4, true, true, true, 0, 10, 30, ids_, &rtrans);
   }
 
   {
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     // Resolve the pending keys.
     GetCryptographer(&rtrans)->DecryptPendingKeys(key_params);
   }
   // First cycle resolves conflicts, second cycle commits changes.
   SyncShareNudge();
-  EXPECT_EQ(2, status().model_neutral_state().num_server_overwrites);
-  EXPECT_EQ(1, status().model_neutral_state().num_local_overwrites);
+  EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_server_overwrites);
+  EXPECT_EQ(1, GetUpdateCounters(PREFERENCES).num_server_overwrites);
+  EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_local_overwrites);
+
   // We successfully commited item(s).
-  EXPECT_EQ(status().model_neutral_state().commit_result, SYNCER_OK);
+  EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_attempted);
+  EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_success);
+  EXPECT_EQ(1, GetCommitCounters(PREFERENCES).num_commits_attempted);
+  EXPECT_EQ(1, GetCommitCounters(PREFERENCES).num_commits_success);
+
   SyncShareNudge();
 
   // Everything should be resolved now. The local changes should have
   // overwritten the server changes for 2 and 4, while the server changes
   // overwrote the local for entry 3.
-  EXPECT_EQ(0, status().model_neutral_state().num_server_overwrites);
-  EXPECT_EQ(0, status().model_neutral_state().num_local_overwrites);
-  EXPECT_EQ(status().model_neutral_state().commit_result, SYNCER_OK);
+  //
+  // Expect there will be no new overwrites.
+  EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_server_overwrites);
+  EXPECT_EQ(1, GetUpdateCounters(BOOKMARKS).num_local_overwrites);
+
+  EXPECT_EQ(2, GetCommitCounters(BOOKMARKS).num_commits_success);
+  EXPECT_EQ(1, GetCommitCounters(PREFERENCES).num_commits_success);
+
   syncable::ReadTransaction rtrans(FROM_HERE, directory());
   VERIFY_ENTRY(1, false, false, false, 0, 41, 41, ids_, &rtrans);
   VERIFY_ENTRY(2, false, false, false, 1, 31, 31, ids_, &rtrans);
   VERIFY_ENTRY(3, false, false, false, 1, 30, 30, ids_, &rtrans);
   VERIFY_ENTRY(4, false, false, false, 0, 31, 31, ids_, &rtrans);
 }
 
 #undef VERIFY_ENTRY
 
 TEST_F(SyncerTest, TestGetUnsyncedAndSimpleCommit) {
@@ skipping 740 matching lines @@
   // because any string sent by the server is a legal server ID in the sync
   // protocol, but it's not the ID of any item known to the client.  This
   // update should succeed validation, but be stuck in the unapplied state
   // until an item with the server ID "-80" arrives.
   mock_server_->AddUpdateDirectory(3, -80, "bad_parent", 10, 10,
                                    foreign_cache_guid(), "-3");
 
   SyncShareNudge();
 
   // Id 3 should be in conflict now.
-  EXPECT_EQ(1, status().TotalNumConflictingItems());
-  EXPECT_EQ(1, status().num_hierarchy_conflicts());
+  EXPECT_EQ(
+      1,
+      GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 
   // The only request in that loop should have been a GetUpdate.
   // At that point, we didn't know whether or not we had conflicts.
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   VerifyHierarchyConflictsUnspecified(mock_server_->last_request());
 
   // These entries will be used in the second set of updates.
   mock_server_->AddUpdateDirectory(4, 0, "newer_version", 20, 10,
                                    foreign_cache_guid(), "-4");
   mock_server_->AddUpdateDirectory(5, 0, "circular1", 10, 10,
                                    foreign_cache_guid(), "-5");
   mock_server_->AddUpdateDirectory(6, 5, "circular2", 10, 10,
                                    foreign_cache_guid(), "-6");
   mock_server_->AddUpdateDirectory(9, 3, "bad_parent_child", 10, 10,
                                    foreign_cache_guid(), "-9");
   mock_server_->AddUpdateDirectory(100, 9, "bad_parent_child2", 10, 10,
                                    foreign_cache_guid(), "-100");
   mock_server_->AddUpdateDirectory(10, 0, "dir_to_bookmark", 10, 10,
                                    foreign_cache_guid(), "-10");
 
   SyncShareNudge();
   // The three items with an unresolved parent should be unapplied (3, 9, 100).
   // The name clash should also still be in conflict.
-  EXPECT_EQ(3, status().TotalNumConflictingItems());
-  EXPECT_EQ(3, status().num_hierarchy_conflicts());
+  EXPECT_EQ(
+      3,
+      GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 
   // This time around, we knew that there were conflicts.
   ASSERT_TRUE(mock_server_->last_request().has_get_updates());
   VerifyHierarchyConflictsReported(mock_server_->last_request());
 
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     // Even though it has the same name, it should work.
     Entry name_clash(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(name_clash.good());
@@ skipping 76 matching lines @@
 
     Entry circular_parent_target(&trans, GET_BY_ID, ids_.FromNumber(6));
     ASSERT_TRUE(circular_parent_target.good());
     EXPECT_FALSE(circular_parent_target.GetIsUnappliedUpdate());
     EXPECT_TRUE(circular_parent_issue.GetId()==
         circular_parent_target.GetParentId());
     EXPECT_EQ(10u, circular_parent_target.GetBaseVersion());
   }
 
   EXPECT_FALSE(saw_syncer_event_);
-  EXPECT_EQ(4, status().TotalNumConflictingItems());
-  EXPECT_EQ(4, status().num_hierarchy_conflicts());
+  EXPECT_EQ(
+      4,
+      GetUpdateCounters(BOOKMARKS).num_hierarchy_conflict_application_failures);
 }
 
 // A commit with a lost response produces an update that has to be reunited with
 // its parent.
 TEST_F(SyncerTest, CommitReuniteUpdateAdjustsChildren) {
   // Create a folder in the root.
   int64 metahandle_folder;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(
@@ skipping 610 matching lines @@
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.PutParentId(newfolder.GetId());
     existing.PutIsUnsynced(true);
     EXPECT_TRUE(existing.GetId().ServerKnows());
 
     newfolder.PutIsDel(true);
     existing.PutIsDel(true);
   }
   SyncShareNudge();
-  EXPECT_EQ(0, status().num_server_conflicts());
+  EXPECT_EQ(0, GetCommitCounters(BOOKMARKS).num_commits_conflict);
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
   SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
@@ skipping 2439 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