sync: Expose DirectoryDebugInfoEmitters in engine

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"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
+#include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/syncable_read_transaction.h"
 #include "sync/syncable/syncable_write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
@@ skipping 24 matching lines @@
     dir_maker_.SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     dir_maker_.TearDown();
   }
 
   syncable::Directory* dir() {
     return dir_maker_.directory();
   }
+
  protected:
   scoped_ptr<sync_pb::SyncEntity> CreateUpdate(
       const std::string& id,
       const std::string& parent,
       const ModelType& type);
 
   // This exists mostly to give tests access to the protected member function.
   // Warning: This takes the syncable directory lock.
   void UpdateSyncEntities(
       DirectoryUpdateHandler* handler,
@@ skipping 48 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) {
-  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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(
       std::string(kCacheGuid, arraysize(kCacheGuid)-1));
@@ skipping 17 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) {
-  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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");
   e->set_folder(true);
@@ skipping 13 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) {
-  DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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=");
 
   // Add it to the applicable updates list.
@@ skipping 10 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) {
-  DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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) {
-  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(
@@ skipping 42 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) {
-  DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS, ui_worker());
+  DirectoryTypeDebugInfoEmitter emitter;
+  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");
 
   sync_pb::DataTypeContext old_context;
   old_context.set_version(1);
@@ skipping 85 matching lines @@
         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
         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_)));
+        new DirectoryUpdateHandler(directory(), BOOKMARKS,
+                                   ui_worker_, &bookmarks_emitter_)));
     update_handler_map_.insert(std::make_pair(
         PASSWORDS,
         new DirectoryUpdateHandler(directory(),
-                                       PASSWORDS,
-                                       password_worker_)));
+                                   PASSWORDS,
+                                   password_worker_,
+                                   &passwords_emitter_)));
   }
 
   virtual void TearDown() OVERRIDE {
     dir_maker_.TearDown();
   }
 
  protected:
   void ApplyBookmarkUpdates(sessions::StatusController* status) {
     update_handler_map_[BOOKMARKS]->ApplyUpdates(status);
   }
@@ skipping 14 matching lines @@
   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_;
 
+  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;
 }
@@ skipping 505 matching lines @@
     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