sync: Populate debug counters for directory types

sync/engine/directory_update_handler_unittest.cc

 // Copyright 2014 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/directory_update_handler.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "sync/engine/syncer_proto_util.h"
@@ skipping 68 matching lines @@
     return ui_worker_;
   }
 
   bool EntryExists(const std::string& id) {
     syncable::ReadTransaction trans(FROM_HERE, dir());
     syncable::Entry e(&trans, syncable::GET_BY_ID,
                       syncable::Id::CreateFromServerId(id));
     return e.good() && !e.GetIsDel();
   }
 
+ protected:
+  // Used in the construction of DirectoryTypeDebugInfoEmitters.
+  ObserverList<TypeDebugInfoObserver> type_observers_;
+
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_refptr<FakeModelWorker> ui_worker_;
 };
 
 scoped_ptr<sync_pb::SyncEntity>
 DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
     const std::string& id,
     const std::string& parent,
@@ skipping 19 matching lines @@
 void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
     DirectoryUpdateHandler* handler,
     const sync_pb::DataTypeProgressMarker& progress) {
   handler->UpdateProgressMarker(progress);
 }
 
 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
 
 // Test that the bookmark tag is set on newly downloaded items.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Add a bookmark item to the update message.
   std::string root = syncable::GetNullId().GetServerId();
   syncable::Id server_id = syncable::Id::CreateFromServerId("b1");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_originator_cache_guid(
@@ skipping 18 matching lines @@
   // If this assertion fails, that might indicate that the algorithm used to
   // generate bookmark tags has been modified.  This could have implications for
   // bookmark ordering.  Please make sure you know what you're doing if you
   // intend to make such a change.
   EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag());
 }
 
 // Test the receipt of a type root node.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Create an update that mimics the bookmark root.
   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
   std::string root = syncable::GetNullId().GetServerId();
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_server_defined_unique_tag("google_chrome_bookmarks");
@@ skipping 14 matching lines @@
   ASSERT_TRUE(entry.good());
 
   EXPECT_FALSE(entry.ShouldMaintainPosition());
   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Test the receipt of a non-bookmark item.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   std::string root = syncable::GetNullId().GetServerId();
   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
   scoped_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL);
   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
 
@@ skipping 11 matching lines @@
   ASSERT_TRUE(entry.good());
 
   EXPECT_FALSE(entry.ShouldMaintainPosition());
   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
 }
 
 // Tests the setting of progress markers.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS));
   progress.set_token("token");
 
   UpdateProgressMarkers(&handler, progress);
 
   sync_pb::DataTypeProgressMarker saved;
   dir()->GetDownloadProgress(BOOKMARKS, &saved);
 
   EXPECT_EQ(progress.token(), saved.token());
   EXPECT_EQ(progress.data_type_id(), saved.data_type_id());
 }
 
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, GarbageCollectionByVersion) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
                                  ui_worker(), &emitter);
   sessions::StatusController status;
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
@@ skipping 44 matching lines @@
   EXPECT_EQ(SYNCER_OK,
             handler.ProcessGetUpdatesResponse(
                 progress, context, SyncEntityList(), &status));
   handler.ApplyUpdates(&status);
   EXPECT_TRUE(EntryExists(type_root->id_string()));
   EXPECT_FALSE(EntryExists(e1->id_string()));
   EXPECT_TRUE(EntryExists(e2->id_string()));
 }
 
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ContextVersion) {
-  DirectoryTypeDebugInfoEmitter emitter;
+  DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
                                  ui_worker(), &emitter);
   sessions::StatusController status;
   int field_number = GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS);
 
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
 
@@ skipping 79 matching lines @@
 // of the time so these tests may end up requiring more infrastructure than the
 // update processing tests.  Currently, we're bypassing most of those issues by
 // using FakeModelWorkers, so there's not much difference between the two test
 // harnesses.
 class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
  public:
   DirectoryUpdateHandlerApplyUpdateTest()
       : ui_worker_(new FakeModelWorker(GROUP_UI)),
         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
+        bookmarks_emitter_(BOOKMARKS, &type_observers_),
+        passwords_emitter_(PASSWORDS, &type_observers_),
         update_handler_map_deleter_(&update_handler_map_) {}
 
   virtual void SetUp() OVERRIDE {
     dir_maker_.SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
 
     update_handler_map_.insert(std::make_pair(
         BOOKMARKS,
         new DirectoryUpdateHandler(directory(), BOOKMARKS,
                                    ui_worker_, &bookmarks_emitter_)));
     update_handler_map_.insert(std::make_pair(
         PASSWORDS,
         new DirectoryUpdateHandler(directory(),
                                    PASSWORDS,
                                    password_worker_,
                                    &passwords_emitter_)));
   }
 
   virtual void TearDown() OVERRIDE {
     dir_maker_.TearDown();
   }
 
+  const UpdateCounters& GetBookmarksUpdateCounters() {
+    return bookmarks_emitter_.GetUpdateCounters();
+  }
+
+  const UpdateCounters& GetPasswordsUpdateCounters() {
+    return passwords_emitter_.GetUpdateCounters();
+  }
+
  protected:
   void ApplyBookmarkUpdates(sessions::StatusController* status) {
     update_handler_map_[BOOKMARKS]->ApplyUpdates(status);
   }
 
   void ApplyPasswordUpdates(sessions::StatusController* status) {
     update_handler_map_[PASSWORDS]->ApplyUpdates(status);
   }
 
   TestEntryFactory* entry_factory() {
     return entry_factory_.get();
   }
 
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
  private:
   typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
 
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<TestEntryFactory> entry_factory_;
 
   scoped_refptr<FakeModelWorker> ui_worker_;
   scoped_refptr<FakeModelWorker> password_worker_;
   scoped_refptr<FakeModelWorker> passive_worker_;
 
+  ObserverList<TypeDebugInfoObserver> type_observers_;
   DirectoryTypeDebugInfoEmitter bookmarks_emitter_;
   DirectoryTypeDebugInfoEmitter passwords_emitter_;
 
   UpdateHandlerMap update_handler_map_;
   STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_;
 };
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 } // namespace
 
 // Test update application for a few bookmark items.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
   sessions::StatusController status;
 
   std::string root_server_id = syncable::GetNullId().GetServerId();
   int64 parent_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "parent", DefaultBookmarkSpecifics(), root_server_id);
   int64 child_handle =
       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
           "child", DefaultBookmarkSpecifics(), "parent");
 
   ApplyBookmarkUpdates(&status);
 
-  EXPECT_EQ(0, status.num_encryption_conflicts())
+  const UpdateCounters& counter = GetBookmarksUpdateCounters();
+  EXPECT_EQ(0, counter.num_encryption_conflict_application_failures)
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(0, status.num_hierarchy_conflicts())
+  EXPECT_EQ(0, counter.num_hierarchy_conflict_application_failures)
       << "Simple update shouldn't result in conflicts";
-  EXPECT_EQ(2, status.num_updates_applied())
+  EXPECT_EQ(2, counter.num_updates_applied)
       << "All items should have been successfully applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
 
     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
 
     ASSERT_TRUE(parent.good());
     ASSERT_TRUE(child.good());
@@ skipping 71 matching lines @@
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     original_server_version = e.GetServerVersion();
     ASSERT_NE(original_server_version, e.GetBaseVersion());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
-  EXPECT_EQ(1, status.num_server_overwrites())
+
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(1, counters.num_server_overwrites)
       << "Unsynced and unapplied item conflict should be resolved";
-  EXPECT_EQ(0, status.num_updates_applied())
+  EXPECT_EQ(0, counters.num_updates_applied)
       << "Update should not be applied; we should override the server.";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_EQ(original_server_version, e.GetServerVersion());
     EXPECT_EQ(original_server_version, e.GetBaseVersion());
     EXPECT_FALSE(e.GetIsUnappliedUpdate());
 
@@ skipping 15 matching lines @@
     // A bad parent indicates a hierarchy conflict.
     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(entry.good());
 
     entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent"));
   }
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
-  EXPECT_EQ(0, status.num_updates_applied());
-  EXPECT_EQ(0, status.num_server_overwrites());
-  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(0, counters.num_updates_applied);
+  EXPECT_EQ(0, counters.num_server_overwrites);
+  EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_TRUE(e.GetIsUnsynced());
   }
 }
 
@@ skipping 24 matching lines @@
 
   // If the server's update were applied, we would have X be a child of Y, and Y
   // as a child of X.  That's a directory loop.  The UpdateApplicator should
   // prevent the update from being applied and note that this is a hierarchy
   // conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   // This should count as a hierarchy conflict.
-  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_TRUE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
 
@@ skipping 17 matching lines @@
   // Create an incoming child from the server.
   int64 child_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "child", DefaultBookmarkSpecifics(), "parent");
 
   // The server's update may seem valid to some other client, but on this client
   // that new item's parent no longer exists.  The update should not be applied
   // and the update applicator should indicate this is a hierarchy conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
-  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
     ASSERT_TRUE(child.good());
     EXPECT_TRUE(child.GetIsUnappliedUpdate());
     EXPECT_FALSE(child.GetIsUnsynced());
   }
 }
 
@@ skipping 23 matching lines @@
       TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"),
       "child", false, BOOKMARKS, NULL);
 
   // The server's request to delete the directory must be ignored, otherwise our
   // unsynced new child would be orphaned.  This is a hierarchy conflict.
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
   // This should count as a hierarchy conflict.
-  EXPECT_EQ(1, status.num_hierarchy_conflicts());
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
     ASSERT_TRUE(parent.good());
     EXPECT_TRUE(parent.GetIsUnappliedUpdate());
     EXPECT_FALSE(parent.GetIsUnsynced());
   }
 }
 
 // Attempt to apply updates where the updated item's parent is not known to this
 // client.  The update application attempt should fail.
 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
        HierarchyConflictUnknownParent) {
   // We shouldn't be able to do anything with either of these items.
   int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
   int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
-  EXPECT_EQ(2, status.num_hierarchy_conflicts())
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "All updates with an unknown ancestors should be in conflict";
-  EXPECT_EQ(0, status.num_updates_applied())
+  EXPECT_EQ(0, counters.num_updates_applied)
       << "No item with an unknown ancestor should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
     syncable::Entry y(&trans, syncable::GET_BY_HANDLE, y_handle);
     ASSERT_TRUE(x.good());
     ASSERT_TRUE(y.good());
     EXPECT_TRUE(x.GetIsUnappliedUpdate());
     EXPECT_TRUE(y.GetIsUnappliedUpdate());
@@ skipping 16 matching lines @@
   int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
   int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
   int64 k4_handle = entry_factory()->CreateUnappliedNewItemWithParent(
       "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
 
-  EXPECT_EQ(2, status.num_hierarchy_conflicts())
+  const UpdateCounters& counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
       << "The updates with unknown ancestors should be in conflict";
-  EXPECT_EQ(4, status.num_updates_applied())
+  EXPECT_EQ(4, counters.num_updates_applied)
       << "The updates with known ancestors should be successfully applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry u1(&trans, syncable::GET_BY_HANDLE, u1_handle);
     syncable::Entry u2(&trans, syncable::GET_BY_HANDLE, u2_handle);
     syncable::Entry k1(&trans, syncable::GET_BY_HANDLE, k1_handle);
     syncable::Entry k2(&trans, syncable::GET_BY_HANDLE, k2_handle);
     syncable::Entry k3(&trans, syncable::GET_BY_HANDLE, k3_handle);
     syncable::Entry k4(&trans, syncable::GET_BY_HANDLE, k4_handle);
@@ skipping 31 matching lines @@
   data.set_origin("http://example.com");
 
   cryptographer->Encrypt(data,
                          specifics.mutable_password()->mutable_encrypted());
   int64 handle =
       entry_factory()->CreateUnappliedNewItem("item", specifics, false);
 
   sessions::StatusController status;
   ApplyPasswordUpdates(&status);
 
-  EXPECT_EQ(1, status.num_updates_applied())
+  const UpdateCounters& counters = GetPasswordsUpdateCounters();
+  EXPECT_EQ(1, counters.num_updates_applied)
       << "The updates that can be decrypted should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
     ASSERT_TRUE(e.good());
     EXPECT_FALSE(e.GetIsUnappliedUpdate());
     EXPECT_FALSE(e.GetIsUnsynced());
   }
 }
@@ skipping 17 matching lines @@
   encrypted_password.mutable_password();
   int64 password_handle = entry_factory()->CreateUnappliedNewItem(
       "item3",
       encrypted_password,
       false);
 
   sessions::StatusController status;
   ApplyBookmarkUpdates(&status);
   ApplyPasswordUpdates(&status);
 
-  EXPECT_EQ(3, status.num_encryption_conflicts())
+  const UpdateCounters& bm_counters = GetBookmarksUpdateCounters();
+  EXPECT_EQ(2, bm_counters.num_encryption_conflict_application_failures)
       << "Updates that can't be decrypted should be in encryption conflict";
-  EXPECT_EQ(0, status.num_updates_applied())
+  EXPECT_EQ(0, bm_counters.num_updates_applied)
+      << "No update that can't be decrypted should be applied";
+
+  const UpdateCounters& pw_counters = GetPasswordsUpdateCounters();
+  EXPECT_EQ(1, pw_counters.num_encryption_conflict_application_failures)
+      << "Updates that can't be decrypted should be in encryption conflict";
+  EXPECT_EQ(0, pw_counters.num_updates_applied)
       << "No update that can't be decrypted should be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry folder(&trans, syncable::GET_BY_HANDLE, folder_handle);
     syncable::Entry bm(&trans, syncable::GET_BY_HANDLE, bookmark_handle);
     syncable::Entry pw(&trans, syncable::GET_BY_HANDLE, password_handle);
     ASSERT_TRUE(folder.good());
     ASSERT_TRUE(bm.good());
     ASSERT_TRUE(pw.good());
@@ skipping 40 matching lines @@
 
     other_cryptographer.Encrypt(data,
         specifics.mutable_password()->mutable_encrypted());
     undecryptable_handle =
         entry_factory()->CreateUnappliedNewItem("item2", specifics, false);
   }
 
   sessions::StatusController status;
   ApplyPasswordUpdates(&status);
 
-  EXPECT_EQ(1, status.num_encryption_conflicts())
+  const UpdateCounters& counters = GetPasswordsUpdateCounters();
+  EXPECT_EQ(1, counters.num_encryption_conflict_application_failures)
       << "The updates that can't be decrypted should be in encryption "
       << "conflict";
-  EXPECT_EQ(1, status.num_updates_applied())
+  EXPECT_EQ(1, counters.num_updates_applied)
       << "The undecryptable password update shouldn't be applied";
 
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, decryptable_handle);
     syncable::Entry e2(&trans, syncable::GET_BY_HANDLE, undecryptable_handle);
     ASSERT_TRUE(e1.good());
     ASSERT_TRUE(e2.good());
     EXPECT_FALSE(e1.GetIsUnappliedUpdate());
     EXPECT_TRUE(e2.GetIsUnappliedUpdate());
   }
 }
 
 }  // namespace syncer