Home | History | Annotate | Download | only in engine 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "sync/engine/directory_update_handler.h"
      6 
      7 #include "base/compiler_specific.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "base/stl_util.h"
     10 #include "sync/engine/syncer_proto_util.h"
     11 #include "sync/internal_api/public/base/attachment_id_proto.h"
     12 #include "sync/internal_api/public/base/model_type.h"
     13 #include "sync/internal_api/public/test/test_entry_factory.h"
     14 #include "sync/protocol/sync.pb.h"
     15 #include "sync/sessions/directory_type_debug_info_emitter.h"
     16 #include "sync/sessions/status_controller.h"
     17 #include "sync/syncable/directory.h"
     18 #include "sync/syncable/entry.h"
     19 #include "sync/syncable/mutable_entry.h"
     20 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
     21 #include "sync/syncable/syncable_proto_util.h"
     22 #include "sync/syncable/syncable_read_transaction.h"
     23 #include "sync/syncable/syncable_write_transaction.h"
     24 #include "sync/test/engine/fake_model_worker.h"
     25 #include "sync/test/engine/test_directory_setter_upper.h"
     26 #include "sync/test/engine/test_id_factory.h"
     27 #include "sync/test/engine/test_syncable_utils.h"
     28 #include "testing/gtest/include/gtest/gtest.h"
     29 
     30 namespace syncer {
     31 
     32 using syncable::UNITTEST;
     33 
     34 static const int64 kDefaultVersion = 1000;
     35 
     36 // A test harness for tests that focus on processing updates.
     37 //
     38 // Update processing is what occurs when we first download updates.  It converts
     39 // the received protobuf message into information in the syncable::Directory.
     40 // Any invalid or redundant updates will be dropped at this point.
     41 class DirectoryUpdateHandlerProcessUpdateTest : public ::testing::Test {
     42  public:
     43   DirectoryUpdateHandlerProcessUpdateTest()
     44       : ui_worker_(new FakeModelWorker(GROUP_UI)) {
     45   }
     46 
     47   virtual ~DirectoryUpdateHandlerProcessUpdateTest() {}
     48 
     49   virtual void SetUp() OVERRIDE {
     50     dir_maker_.SetUp();
     51   }
     52 
     53   virtual void TearDown() OVERRIDE {
     54     dir_maker_.TearDown();
     55   }
     56 
     57   syncable::Directory* dir() {
     58     return dir_maker_.directory();
     59   }
     60 
     61  protected:
     62   scoped_ptr<sync_pb::SyncEntity> CreateUpdate(
     63       const std::string& id,
     64       const std::string& parent,
     65       const ModelType& type);
     66 
     67   // This exists mostly to give tests access to the protected member function.
     68   // Warning: This takes the syncable directory lock.
     69   void UpdateSyncEntities(
     70       DirectoryUpdateHandler* handler,
     71       const SyncEntityList& applicable_updates,
     72       sessions::StatusController* status);
     73 
     74   // Another function to access private member functions.
     75   void UpdateProgressMarkers(
     76       DirectoryUpdateHandler* handler,
     77       const sync_pb::DataTypeProgressMarker& progress);
     78 
     79   scoped_refptr<FakeModelWorker> ui_worker() {
     80     return ui_worker_;
     81   }
     82 
     83   bool EntryExists(const std::string& id) {
     84     syncable::ReadTransaction trans(FROM_HERE, dir());
     85     syncable::Entry e(&trans, syncable::GET_BY_ID,
     86                       syncable::Id::CreateFromServerId(id));
     87     return e.good() && !e.GetIsDel();
     88   }
     89 
     90  protected:
     91   // Used in the construction of DirectoryTypeDebugInfoEmitters.
     92   ObserverList<TypeDebugInfoObserver> type_observers_;
     93 
     94  private:
     95   base::MessageLoop loop_;  // Needed to initialize the directory.
     96   TestDirectorySetterUpper dir_maker_;
     97   scoped_refptr<FakeModelWorker> ui_worker_;
     98 };
     99 
    100 scoped_ptr<sync_pb::SyncEntity>
    101 DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
    102     const std::string& id,
    103     const std::string& parent,
    104     const ModelType& type) {
    105   scoped_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity());
    106   e->set_id_string(id);
    107   e->set_parent_id_string(parent);
    108   e->set_non_unique_name(id);
    109   e->set_name(id);
    110   e->set_version(kDefaultVersion);
    111   AddDefaultFieldValue(type, e->mutable_specifics());
    112   return e.Pass();
    113 }
    114 
    115 void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
    116     DirectoryUpdateHandler* handler,
    117     const SyncEntityList& applicable_updates,
    118     sessions::StatusController* status) {
    119   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, UNITTEST, dir());
    120   handler->UpdateSyncEntities(&trans, applicable_updates, status);
    121 }
    122 
    123 void DirectoryUpdateHandlerProcessUpdateTest::UpdateProgressMarkers(
    124     DirectoryUpdateHandler* handler,
    125     const sync_pb::DataTypeProgressMarker& progress) {
    126   handler->UpdateProgressMarker(progress);
    127 }
    128 
    129 static const char kCacheGuid[] = "IrcjZ2jyzHDV9Io4+zKcXQ==";
    130 
    131 // Test that the bookmark tag is set on newly downloaded items.
    132 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
    133   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
    134   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
    135   sync_pb::GetUpdatesResponse gu_response;
    136   sessions::StatusController status;
    137 
    138   // Add a bookmark item to the update message.
    139   std::string root = syncable::GetNullId().GetServerId();
    140   syncable::Id server_id = syncable::Id::CreateFromServerId("b1");
    141   scoped_ptr<sync_pb::SyncEntity> e =
    142       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
    143   e->set_originator_cache_guid(
    144       std::string(kCacheGuid, arraysize(kCacheGuid)-1));
    145   syncable::Id client_id = syncable::Id::CreateFromClientString("-2");
    146   e->set_originator_client_item_id(client_id.GetServerId());
    147   e->set_position_in_parent(0);
    148 
    149   // Add it to the applicable updates list.
    150   SyncEntityList bookmark_updates;
    151   bookmark_updates.push_back(e.get());
    152 
    153   // Process the update.
    154   UpdateSyncEntities(&handler, bookmark_updates, &status);
    155 
    156   syncable::ReadTransaction trans(FROM_HERE, dir());
    157   syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id);
    158   ASSERT_TRUE(entry.good());
    159   EXPECT_TRUE(UniquePosition::IsValidSuffix(entry.GetUniqueBookmarkTag()));
    160   EXPECT_TRUE(entry.GetServerUniquePosition().IsValid());
    161 
    162   // If this assertion fails, that might indicate that the algorithm used to
    163   // generate bookmark tags has been modified.  This could have implications for
    164   // bookmark ordering.  Please make sure you know what you're doing if you
    165   // intend to make such a change.
    166   EXPECT_EQ("6wHRAb3kbnXV5GHrejp4/c1y5tw=", entry.GetUniqueBookmarkTag());
    167 }
    168 
    169 // Test the receipt of a type root node.
    170 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
    171        ReceiveServerCreatedBookmarkFolders) {
    172   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
    173   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
    174   sync_pb::GetUpdatesResponse gu_response;
    175   sessions::StatusController status;
    176 
    177   // Create an update that mimics the bookmark root.
    178   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
    179   std::string root = syncable::GetNullId().GetServerId();
    180   scoped_ptr<sync_pb::SyncEntity> e =
    181       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
    182   e->set_server_defined_unique_tag("google_chrome_bookmarks");
    183   e->set_folder(true);
    184 
    185   // Add it to the applicable updates list.
    186   SyncEntityList bookmark_updates;
    187   bookmark_updates.push_back(e.get());
    188 
    189   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
    190 
    191   // Process it.
    192   UpdateSyncEntities(&handler, bookmark_updates, &status);
    193 
    194   // Verify the results.
    195   syncable::ReadTransaction trans(FROM_HERE, dir());
    196   syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id);
    197   ASSERT_TRUE(entry.good());
    198 
    199   EXPECT_FALSE(entry.ShouldMaintainPosition());
    200   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
    201   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
    202   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
    203 }
    204 
    205 // Test the receipt of a non-bookmark item.
    206 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
    207   DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
    208   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
    209   sync_pb::GetUpdatesResponse gu_response;
    210   sessions::StatusController status;
    211 
    212   std::string root = syncable::GetNullId().GetServerId();
    213   syncable::Id server_id = syncable::Id::CreateFromServerId("xyz");
    214   scoped_ptr<sync_pb::SyncEntity> e =
    215       CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL);
    216   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
    217 
    218   // Add it to the applicable updates list.
    219   SyncEntityList autofill_updates;
    220   autofill_updates.push_back(e.get());
    221 
    222   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
    223 
    224   // Process it.
    225   UpdateSyncEntities(&handler, autofill_updates, &status);
    226 
    227   syncable::ReadTransaction trans(FROM_HERE, dir());
    228   syncable::Entry entry(&trans, syncable::GET_BY_ID, server_id);
    229   ASSERT_TRUE(entry.good());
    230 
    231   EXPECT_FALSE(entry.ShouldMaintainPosition());
    232   EXPECT_FALSE(entry.GetUniquePosition().IsValid());
    233   EXPECT_FALSE(entry.GetServerUniquePosition().IsValid());
    234   EXPECT_TRUE(entry.GetUniqueBookmarkTag().empty());
    235 }
    236 
    237 // Tests the setting of progress markers.
    238 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ProcessNewProgressMarkers) {
    239   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
    240   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
    241 
    242   sync_pb::DataTypeProgressMarker progress;
    243   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(BOOKMARKS));
    244   progress.set_token("token");
    245 
    246   UpdateProgressMarkers(&handler, progress);
    247 
    248   sync_pb::DataTypeProgressMarker saved;
    249   dir()->GetDownloadProgress(BOOKMARKS, &saved);
    250 
    251   EXPECT_EQ(progress.token(), saved.token());
    252   EXPECT_EQ(progress.data_type_id(), saved.data_type_id());
    253 }
    254 
    255 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, GarbageCollectionByVersion) {
    256   DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
    257   DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
    258                                  ui_worker(), &emitter);
    259   sessions::StatusController status;
    260 
    261   sync_pb::DataTypeProgressMarker progress;
    262   progress.set_data_type_id(
    263       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
    264   progress.set_token("token");
    265   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
    266 
    267   sync_pb::DataTypeContext context;
    268   context.set_data_type_id(
    269       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
    270   context.set_context("context");
    271   context.set_version(1);
    272 
    273   scoped_ptr<sync_pb::SyncEntity> type_root =
    274       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
    275                    syncable::GetNullId().GetServerId(),
    276                    SYNCED_NOTIFICATIONS);
    277   type_root->set_server_defined_unique_tag(
    278       ModelTypeToRootTag(SYNCED_NOTIFICATIONS));
    279   type_root->set_folder(true);
    280 
    281   scoped_ptr<sync_pb::SyncEntity> e1 =
    282       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
    283                    type_root->id_string(),
    284                    SYNCED_NOTIFICATIONS);
    285 
    286   scoped_ptr<sync_pb::SyncEntity> e2 =
    287       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")),
    288                    type_root->id_string(),
    289                    SYNCED_NOTIFICATIONS);
    290   e2->set_version(kDefaultVersion + 100);
    291 
    292   // Add to the applicable updates list.
    293   SyncEntityList updates;
    294   updates.push_back(type_root.get());
    295   updates.push_back(e1.get());
    296   updates.push_back(e2.get());
    297 
    298   // Process and apply updates.
    299   EXPECT_EQ(
    300       SYNCER_OK,
    301       handler.ProcessGetUpdatesResponse(progress, context, updates, &status));
    302   handler.ApplyUpdates(&status);
    303 
    304   // Verify none is deleted because they are unapplied during GC.
    305   EXPECT_TRUE(EntryExists(type_root->id_string()));
    306   EXPECT_TRUE(EntryExists(e1->id_string()));
    307   EXPECT_TRUE(EntryExists(e2->id_string()));
    308 
    309   // Process and apply again. Old entry is deleted but not root.
    310   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 20);
    311   EXPECT_EQ(SYNCER_OK,
    312             handler.ProcessGetUpdatesResponse(
    313                 progress, context, SyncEntityList(), &status));
    314   handler.ApplyUpdates(&status);
    315   EXPECT_TRUE(EntryExists(type_root->id_string()));
    316   EXPECT_FALSE(EntryExists(e1->id_string()));
    317   EXPECT_TRUE(EntryExists(e2->id_string()));
    318 }
    319 
    320 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ContextVersion) {
    321   DirectoryTypeDebugInfoEmitter emitter(SYNCED_NOTIFICATIONS, &type_observers_);
    322   DirectoryUpdateHandler handler(dir(), SYNCED_NOTIFICATIONS,
    323                                  ui_worker(), &emitter);
    324   sessions::StatusController status;
    325   int field_number = GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS);
    326 
    327   sync_pb::DataTypeProgressMarker progress;
    328   progress.set_data_type_id(
    329       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
    330   progress.set_token("token");
    331 
    332   sync_pb::DataTypeContext old_context;
    333   old_context.set_version(1);
    334   old_context.set_context("data");
    335   old_context.set_data_type_id(field_number);
    336 
    337   scoped_ptr<sync_pb::SyncEntity> type_root =
    338       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
    339                    syncable::GetNullId().GetServerId(),
    340                    SYNCED_NOTIFICATIONS);
    341   type_root->set_server_defined_unique_tag(
    342       ModelTypeToRootTag(SYNCED_NOTIFICATIONS));
    343   type_root->set_folder(true);
    344   scoped_ptr<sync_pb::SyncEntity> e1 =
    345       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
    346                    type_root->id_string(),
    347                    SYNCED_NOTIFICATIONS);
    348 
    349   SyncEntityList updates;
    350   updates.push_back(type_root.get());
    351   updates.push_back(e1.get());
    352 
    353   // The first response should be processed fine.
    354   EXPECT_EQ(SYNCER_OK,
    355             handler.ProcessGetUpdatesResponse(
    356                 progress, old_context, updates, &status));
    357   handler.ApplyUpdates(&status);
    358 
    359   EXPECT_TRUE(EntryExists(type_root->id_string()));
    360   EXPECT_TRUE(EntryExists(e1->id_string()));
    361 
    362   {
    363     sync_pb::DataTypeContext dir_context;
    364     syncable::ReadTransaction trans(FROM_HERE, dir());
    365     trans.directory()->GetDataTypeContext(
    366         &trans, SYNCED_NOTIFICATIONS, &dir_context);
    367     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
    368   }
    369 
    370   sync_pb::DataTypeContext new_context;
    371   new_context.set_version(0);
    372   new_context.set_context("old");
    373   new_context.set_data_type_id(field_number);
    374 
    375   scoped_ptr<sync_pb::SyncEntity> e2 =
    376       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e2")),
    377                    type_root->id_string(),
    378                    SYNCED_NOTIFICATIONS);
    379   updates.clear();
    380   updates.push_back(e2.get());
    381 
    382   // The second response, with an old context version, should result in an
    383   // error and the updates should be dropped.
    384   EXPECT_EQ(DATATYPE_TRIGGERED_RETRY,
    385             handler.ProcessGetUpdatesResponse(
    386                 progress, new_context, updates, &status));
    387   handler.ApplyUpdates(&status);
    388 
    389   EXPECT_FALSE(EntryExists(e2->id_string()));
    390 
    391   {
    392     sync_pb::DataTypeContext dir_context;
    393     syncable::ReadTransaction trans(FROM_HERE, dir());
    394     trans.directory()->GetDataTypeContext(
    395         &trans, SYNCED_NOTIFICATIONS, &dir_context);
    396     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
    397   }
    398 }
    399 
    400 // See that updates containing attachment metadata are applied
    401 // (i.e. server_attachment_metadata is copied to attachment_metadata).
    402 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
    403        ProcessAndApplyUpdatesWithAttachments) {
    404   DirectoryTypeDebugInfoEmitter emitter(ARTICLES, &type_observers_);
    405   DirectoryUpdateHandler handler(dir(), ARTICLES, ui_worker(), &emitter);
    406   sessions::StatusController status;
    407 
    408   sync_pb::DataTypeProgressMarker progress;
    409   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
    410   progress.set_token("token");
    411   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
    412 
    413   sync_pb::DataTypeContext context;
    414   context.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
    415   context.set_context("context");
    416   context.set_version(1);
    417 
    418   scoped_ptr<sync_pb::SyncEntity> type_root =
    419       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("root")),
    420                    syncable::GetNullId().GetServerId(),
    421                    ARTICLES);
    422   type_root->set_server_defined_unique_tag(ModelTypeToRootTag(ARTICLES));
    423   type_root->set_folder(true);
    424 
    425   scoped_ptr<sync_pb::SyncEntity> e1 =
    426       CreateUpdate(SyncableIdToProto(syncable::Id::CreateFromServerId("e1")),
    427                    type_root->id_string(),
    428                    ARTICLES);
    429   sync_pb::AttachmentIdProto* attachment_id = e1->add_attachment_id();
    430   *attachment_id = CreateAttachmentIdProto();
    431 
    432   SyncEntityList updates;
    433   updates.push_back(type_root.get());
    434   updates.push_back(e1.get());
    435 
    436   // Process and apply updates.
    437   EXPECT_EQ(
    438       SYNCER_OK,
    439       handler.ProcessGetUpdatesResponse(progress, context, updates, &status));
    440   handler.ApplyUpdates(&status);
    441 
    442   ASSERT_TRUE(EntryExists(type_root->id_string()));
    443   ASSERT_TRUE(EntryExists(e1->id_string()));
    444   {
    445     syncable::ReadTransaction trans(FROM_HERE, dir());
    446     syncable::Entry e(&trans,
    447                       syncable::GET_BY_ID,
    448                       syncable::Id::CreateFromServerId(e1->id_string()));
    449 
    450     // See that the attachment_metadata is correct.
    451     sync_pb::AttachmentMetadata attachment_metadata = e.GetAttachmentMetadata();
    452     ASSERT_EQ(1, attachment_metadata.record_size());
    453     ASSERT_EQ(attachment_id->SerializeAsString(),
    454               attachment_metadata.record(0).id().SerializeAsString());
    455     ASSERT_TRUE(attachment_metadata.record(0).is_on_server());
    456 
    457     // See that attachment_metadata and server_attachment_metadata are equal.
    458     ASSERT_EQ(attachment_metadata.SerializeAsString(),
    459               e.GetServerAttachmentMetadata().SerializeAsString());
    460   }
    461 }
    462 
    463 // A test harness for tests that focus on applying updates.
    464 //
    465 // Update application is performed when we want to take updates that were
    466 // previously downloaded, processed, and stored in our syncable::Directory
    467 // and use them to update our local state (both the Directory's local state
    468 // and the model's local state, though these tests focus only on the Directory's
    469 // local state).
    470 //
    471 // This is kept separate from the update processing test in part for historical
    472 // reasons, and in part because these tests may require a bit more infrastrcture
    473 // in the future.  Update application should happen on a different thread a lot
    474 // of the time so these tests may end up requiring more infrastructure than the
    475 // update processing tests.  Currently, we're bypassing most of those issues by
    476 // using FakeModelWorkers, so there's not much difference between the two test
    477 // harnesses.
    478 class DirectoryUpdateHandlerApplyUpdateTest : public ::testing::Test {
    479  public:
    480   DirectoryUpdateHandlerApplyUpdateTest()
    481       : ui_worker_(new FakeModelWorker(GROUP_UI)),
    482         password_worker_(new FakeModelWorker(GROUP_PASSWORD)),
    483         passive_worker_(new FakeModelWorker(GROUP_PASSIVE)),
    484         bookmarks_emitter_(BOOKMARKS, &type_observers_),
    485         passwords_emitter_(PASSWORDS, &type_observers_),
    486         articles_emitter_(ARTICLES, &type_observers_),
    487         update_handler_map_deleter_(&update_handler_map_) {}
    488 
    489   virtual void SetUp() OVERRIDE {
    490     dir_maker_.SetUp();
    491     entry_factory_.reset(new TestEntryFactory(directory()));
    492 
    493     update_handler_map_.insert(std::make_pair(
    494         BOOKMARKS,
    495         new DirectoryUpdateHandler(directory(), BOOKMARKS,
    496                                    ui_worker_, &bookmarks_emitter_)));
    497     update_handler_map_.insert(std::make_pair(
    498         PASSWORDS,
    499         new DirectoryUpdateHandler(directory(),
    500                                    PASSWORDS,
    501                                    password_worker_,
    502                                    &passwords_emitter_)));
    503     update_handler_map_.insert(std::make_pair(
    504         ARTICLES,
    505         new DirectoryUpdateHandler(
    506             directory(), ARTICLES, ui_worker_, &articles_emitter_)));
    507   }
    508 
    509   virtual void TearDown() OVERRIDE {
    510     dir_maker_.TearDown();
    511   }
    512 
    513   const UpdateCounters& GetBookmarksUpdateCounters() {
    514     return bookmarks_emitter_.GetUpdateCounters();
    515   }
    516 
    517   const UpdateCounters& GetPasswordsUpdateCounters() {
    518     return passwords_emitter_.GetUpdateCounters();
    519   }
    520 
    521   const UpdateCounters& GetArticlesUpdateCounters() {
    522     return articles_emitter_.GetUpdateCounters();
    523   }
    524 
    525  protected:
    526   void ApplyBookmarkUpdates(sessions::StatusController* status) {
    527     update_handler_map_[BOOKMARKS]->ApplyUpdates(status);
    528   }
    529 
    530   void ApplyPasswordUpdates(sessions::StatusController* status) {
    531     update_handler_map_[PASSWORDS]->ApplyUpdates(status);
    532   }
    533 
    534   void ApplyArticlesUpdates(sessions::StatusController* status) {
    535     update_handler_map_[ARTICLES]->ApplyUpdates(status);
    536   }
    537 
    538   TestEntryFactory* entry_factory() {
    539     return entry_factory_.get();
    540   }
    541 
    542   syncable::Directory* directory() {
    543     return dir_maker_.directory();
    544   }
    545 
    546  private:
    547   typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
    548 
    549   base::MessageLoop loop_;  // Needed to initialize the directory.
    550   TestDirectorySetterUpper dir_maker_;
    551   scoped_ptr<TestEntryFactory> entry_factory_;
    552 
    553   scoped_refptr<FakeModelWorker> ui_worker_;
    554   scoped_refptr<FakeModelWorker> password_worker_;
    555   scoped_refptr<FakeModelWorker> passive_worker_;
    556 
    557   ObserverList<TypeDebugInfoObserver> type_observers_;
    558   DirectoryTypeDebugInfoEmitter bookmarks_emitter_;
    559   DirectoryTypeDebugInfoEmitter passwords_emitter_;
    560   DirectoryTypeDebugInfoEmitter articles_emitter_;
    561 
    562   UpdateHandlerMap update_handler_map_;
    563   STLValueDeleter<UpdateHandlerMap> update_handler_map_deleter_;
    564 };
    565 
    566 namespace {
    567 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
    568   sync_pb::EntitySpecifics result;
    569   AddDefaultFieldValue(BOOKMARKS, &result);
    570   return result;
    571 }
    572 } // namespace
    573 
    574 // Test update application for a few bookmark items.
    575 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmark) {
    576   sessions::StatusController status;
    577 
    578   std::string root_server_id = syncable::GetNullId().GetServerId();
    579   int64 parent_handle =
    580       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    581           "parent", DefaultBookmarkSpecifics(), root_server_id);
    582   int64 child_handle =
    583       entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    584           "child", DefaultBookmarkSpecifics(), "parent");
    585 
    586   ApplyBookmarkUpdates(&status);
    587 
    588   const UpdateCounters& counter = GetBookmarksUpdateCounters();
    589   EXPECT_EQ(0, counter.num_encryption_conflict_application_failures)
    590       << "Simple update shouldn't result in conflicts";
    591   EXPECT_EQ(0, counter.num_hierarchy_conflict_application_failures)
    592       << "Simple update shouldn't result in conflicts";
    593   EXPECT_EQ(2, counter.num_updates_applied)
    594       << "All items should have been successfully applied";
    595 
    596   {
    597     syncable::ReadTransaction trans(FROM_HERE, directory());
    598 
    599     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
    600     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
    601 
    602     ASSERT_TRUE(parent.good());
    603     ASSERT_TRUE(child.good());
    604 
    605     EXPECT_FALSE(parent.GetIsUnsynced());
    606     EXPECT_FALSE(parent.GetIsUnappliedUpdate());
    607     EXPECT_FALSE(child.GetIsUnsynced());
    608     EXPECT_FALSE(child.GetIsUnappliedUpdate());
    609   }
    610 }
    611 
    612 // Test that the applicator can handle updates delivered out of order.
    613 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
    614        BookmarkChildrenBeforeParent) {
    615   // Start with some bookmarks whose parents are unknown.
    616   std::string root_server_id = syncable::GetNullId().GetServerId();
    617   int64 a_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    618       "a_child_created_first", DefaultBookmarkSpecifics(), "parent");
    619   int64 x_handle = entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    620       "x_child_created_first", DefaultBookmarkSpecifics(), "parent");
    621 
    622   // Update application will fail.
    623   sessions::StatusController status1;
    624   ApplyBookmarkUpdates(&status1);
    625   EXPECT_EQ(0, status1.num_updates_applied());
    626   EXPECT_EQ(2, status1.num_hierarchy_conflicts());
    627 
    628   {
    629     syncable::ReadTransaction trans(FROM_HERE, directory());
    630 
    631     syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle);
    632     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
    633 
    634     ASSERT_TRUE(a.good());
    635     ASSERT_TRUE(x.good());
    636 
    637     EXPECT_TRUE(a.GetIsUnappliedUpdate());
    638     EXPECT_TRUE(x.GetIsUnappliedUpdate());
    639   }
    640 
    641   // Now add their parent and a few siblings.
    642   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    643       "parent", DefaultBookmarkSpecifics(), root_server_id);
    644   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    645       "a_child_created_second", DefaultBookmarkSpecifics(), "parent");
    646   entry_factory()->CreateUnappliedNewBookmarkItemWithParent(
    647       "x_child_created_second", DefaultBookmarkSpecifics(), "parent");
    648 
    649   // Update application will succeed.
    650   sessions::StatusController status2;
    651   ApplyBookmarkUpdates(&status2);
    652   EXPECT_EQ(5, status2.num_updates_applied())
    653       << "All updates should have been successfully applied";
    654 
    655   {
    656     syncable::ReadTransaction trans(FROM_HERE, directory());
    657 
    658     syncable::Entry a(&trans, syncable::GET_BY_HANDLE, a_handle);
    659     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
    660 
    661     ASSERT_TRUE(a.good());
    662     ASSERT_TRUE(x.good());
    663 
    664     EXPECT_FALSE(a.GetIsUnappliedUpdate());
    665     EXPECT_FALSE(x.GetIsUnappliedUpdate());
    666   }
    667 }
    668 
    669 // Try to apply changes on an item that is both IS_UNSYNCED and
    670 // IS_UNAPPLIED_UPDATE.  Conflict resolution should be performed.
    671 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SimpleBookmarkConflict) {
    672   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem("x");
    673 
    674   int original_server_version = -10;
    675   {
    676     syncable::ReadTransaction trans(FROM_HERE, directory());
    677     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
    678     original_server_version = e.GetServerVersion();
    679     ASSERT_NE(original_server_version, e.GetBaseVersion());
    680     EXPECT_TRUE(e.GetIsUnsynced());
    681   }
    682 
    683   sessions::StatusController status;
    684   ApplyBookmarkUpdates(&status);
    685 
    686   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    687   EXPECT_EQ(1, counters.num_server_overwrites)
    688       << "Unsynced and unapplied item conflict should be resolved";
    689   EXPECT_EQ(0, counters.num_updates_applied)
    690       << "Update should not be applied; we should override the server.";
    691 
    692   {
    693     syncable::ReadTransaction trans(FROM_HERE, directory());
    694     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
    695     ASSERT_TRUE(e.good());
    696     EXPECT_EQ(original_server_version, e.GetServerVersion());
    697     EXPECT_EQ(original_server_version, e.GetBaseVersion());
    698     EXPECT_FALSE(e.GetIsUnappliedUpdate());
    699 
    700     // The unsynced flag will remain set until we successfully commit the item.
    701     EXPECT_TRUE(e.GetIsUnsynced());
    702   }
    703 }
    704 
    705 // Create a simple conflict that is also a hierarchy conflict.  If we were to
    706 // follow the normal "server wins" logic, we'd end up violating hierarchy
    707 // constraints.  The hierarchy conflict must take precedence.  We can not allow
    708 // the update to be applied.  The item must remain in the conflict state.
    709 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, HierarchyAndSimpleConflict) {
    710   // Create a simply-conflicting item.  It will start with valid parent ids.
    711   int64 handle = entry_factory()->CreateUnappliedAndUnsyncedBookmarkItem(
    712       "orphaned_by_server");
    713   {
    714     // Manually set the SERVER_PARENT_ID to bad value.
    715     // A bad parent indicates a hierarchy conflict.
    716     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
    717     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
    718     ASSERT_TRUE(entry.good());
    719 
    720     entry.PutServerParentId(TestIdFactory::MakeServer("bogus_parent"));
    721   }
    722 
    723   sessions::StatusController status;
    724   ApplyBookmarkUpdates(&status);
    725 
    726   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    727   EXPECT_EQ(0, counters.num_updates_applied);
    728   EXPECT_EQ(0, counters.num_server_overwrites);
    729   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
    730 
    731   {
    732     syncable::ReadTransaction trans(FROM_HERE, directory());
    733     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
    734     ASSERT_TRUE(e.good());
    735     EXPECT_TRUE(e.GetIsUnappliedUpdate());
    736     EXPECT_TRUE(e.GetIsUnsynced());
    737   }
    738 }
    739 
    740 // Attempt to apply an udpate that would create a bookmark folder loop.  This
    741 // application should fail.
    742 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, BookmarkFolderLoop) {
    743   // Item 'X' locally has parent of 'root'.  Server is updating it to have
    744   // parent of 'Y'.
    745 
    746   // Create it as a child of root node.
    747   int64 handle = entry_factory()->CreateSyncedItem("X", BOOKMARKS, true);
    748 
    749   {
    750     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
    751     syncable::MutableEntry entry(&trans, syncable::GET_BY_HANDLE, handle);
    752     ASSERT_TRUE(entry.good());
    753 
    754     // Re-parent from root to "Y"
    755     entry.PutServerVersion(entry_factory()->GetNextRevision());
    756     entry.PutIsUnappliedUpdate(true);
    757     entry.PutServerParentId(TestIdFactory::MakeServer("Y"));
    758   }
    759 
    760   // Item 'Y' is child of 'X'.
    761   entry_factory()->CreateUnsyncedItem(
    762       TestIdFactory::MakeServer("Y"), TestIdFactory::MakeServer("X"), "Y", true,
    763       BOOKMARKS, NULL);
    764 
    765   // If the server's update were applied, we would have X be a child of Y, and Y
    766   // as a child of X.  That's a directory loop.  The UpdateApplicator should
    767   // prevent the update from being applied and note that this is a hierarchy
    768   // conflict.
    769 
    770   sessions::StatusController status;
    771   ApplyBookmarkUpdates(&status);
    772 
    773   // This should count as a hierarchy conflict.
    774   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    775   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
    776 
    777   {
    778     syncable::ReadTransaction trans(FROM_HERE, directory());
    779     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
    780     ASSERT_TRUE(e.good());
    781     EXPECT_TRUE(e.GetIsUnappliedUpdate());
    782     EXPECT_FALSE(e.GetIsUnsynced());
    783   }
    784 }
    785 
    786 // Test update application where the update has been orphaned by a local folder
    787 // deletion.  The update application attempt should fail.
    788 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
    789        HierarchyConflictDeletedParent) {
    790   // Create a locally deleted parent item.
    791   int64 parent_handle;
    792   entry_factory()->CreateUnsyncedItem(
    793       syncable::Id::CreateFromServerId("parent"), TestIdFactory::root(),
    794       "parent", true, BOOKMARKS, &parent_handle);
    795   {
    796     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
    797     syncable::MutableEntry entry(&trans,
    798                                  syncable::GET_BY_HANDLE,
    799                                  parent_handle);
    800     entry.PutIsDel(true);
    801   }
    802 
    803   // Create an incoming child from the server.
    804   int64 child_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    805       "child", DefaultBookmarkSpecifics(), "parent");
    806 
    807   // The server's update may seem valid to some other client, but on this client
    808   // that new item's parent no longer exists.  The update should not be applied
    809   // and the update applicator should indicate this is a hierarchy conflict.
    810 
    811   sessions::StatusController status;
    812   ApplyBookmarkUpdates(&status);
    813   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    814   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
    815 
    816   {
    817     syncable::ReadTransaction trans(FROM_HERE, directory());
    818     syncable::Entry child(&trans, syncable::GET_BY_HANDLE, child_handle);
    819     ASSERT_TRUE(child.good());
    820     EXPECT_TRUE(child.GetIsUnappliedUpdate());
    821     EXPECT_FALSE(child.GetIsUnsynced());
    822   }
    823 }
    824 
    825 // Attempt to apply an update that deletes a folder where the folder has
    826 // locally-created children.  The update application should fail.
    827 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
    828        HierarchyConflictDeleteNonEmptyDirectory) {
    829   // Create a server-deleted folder as a child of root node.
    830   int64 parent_handle =
    831       entry_factory()->CreateSyncedItem("parent", BOOKMARKS, true);
    832   {
    833     syncable::WriteTransaction trans(FROM_HERE, UNITTEST, directory());
    834     syncable::MutableEntry entry(&trans,
    835                                  syncable::GET_BY_HANDLE,
    836                                  parent_handle);
    837     ASSERT_TRUE(entry.good());
    838 
    839     // Delete it on the server.
    840     entry.PutServerVersion(entry_factory()->GetNextRevision());
    841     entry.PutIsUnappliedUpdate(true);
    842     entry.PutServerParentId(TestIdFactory::root());
    843     entry.PutServerIsDel(true);
    844   }
    845 
    846   // Create a local child of the server-deleted directory.
    847   entry_factory()->CreateUnsyncedItem(
    848       TestIdFactory::MakeServer("child"), TestIdFactory::MakeServer("parent"),
    849       "child", false, BOOKMARKS, NULL);
    850 
    851   // The server's request to delete the directory must be ignored, otherwise our
    852   // unsynced new child would be orphaned.  This is a hierarchy conflict.
    853 
    854   sessions::StatusController status;
    855   ApplyBookmarkUpdates(&status);
    856 
    857   // This should count as a hierarchy conflict.
    858   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    859   EXPECT_EQ(1, counters.num_hierarchy_conflict_application_failures);
    860 
    861   {
    862     syncable::ReadTransaction trans(FROM_HERE, directory());
    863     syncable::Entry parent(&trans, syncable::GET_BY_HANDLE, parent_handle);
    864     ASSERT_TRUE(parent.good());
    865     EXPECT_TRUE(parent.GetIsUnappliedUpdate());
    866     EXPECT_FALSE(parent.GetIsUnsynced());
    867   }
    868 }
    869 
    870 // Attempt to apply updates where the updated item's parent is not known to this
    871 // client.  The update application attempt should fail.
    872 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
    873        HierarchyConflictUnknownParent) {
    874   // We shouldn't be able to do anything with either of these items.
    875   int64 x_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    876       "some_item", DefaultBookmarkSpecifics(), "unknown_parent");
    877   int64 y_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    878       "some_other_item", DefaultBookmarkSpecifics(), "some_item");
    879 
    880   sessions::StatusController status;
    881   ApplyBookmarkUpdates(&status);
    882 
    883   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    884   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
    885       << "All updates with an unknown ancestors should be in conflict";
    886   EXPECT_EQ(0, counters.num_updates_applied)
    887       << "No item with an unknown ancestor should be applied";
    888 
    889   {
    890     syncable::ReadTransaction trans(FROM_HERE, directory());
    891     syncable::Entry x(&trans, syncable::GET_BY_HANDLE, x_handle);
    892     syncable::Entry y(&trans, syncable::GET_BY_HANDLE, y_handle);
    893     ASSERT_TRUE(x.good());
    894     ASSERT_TRUE(y.good());
    895     EXPECT_TRUE(x.GetIsUnappliedUpdate());
    896     EXPECT_TRUE(y.GetIsUnappliedUpdate());
    897     EXPECT_FALSE(x.GetIsUnsynced());
    898     EXPECT_FALSE(y.GetIsUnsynced());
    899   }
    900 }
    901 
    902 // Attempt application of a mix of items.  Some update application attempts will
    903 // fail due to hierarchy conflicts.  Others should succeed.
    904 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, ItemsBothKnownAndUnknown) {
    905   // See what happens when there's a mixture of good and bad updates.
    906   std::string root_server_id = syncable::GetNullId().GetServerId();
    907   int64 u1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    908       "first_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
    909   int64 k1_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    910       "first_known_item", DefaultBookmarkSpecifics(), root_server_id);
    911   int64 u2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    912       "second_unknown_item", DefaultBookmarkSpecifics(), "unknown_parent");
    913   int64 k2_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    914       "second_known_item", DefaultBookmarkSpecifics(), "first_known_item");
    915   int64 k3_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    916       "third_known_item", DefaultBookmarkSpecifics(), "fourth_known_item");
    917   int64 k4_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    918       "fourth_known_item", DefaultBookmarkSpecifics(), root_server_id);
    919 
    920   sessions::StatusController status;
    921   ApplyBookmarkUpdates(&status);
    922 
    923   const UpdateCounters& counters = GetBookmarksUpdateCounters();
    924   EXPECT_EQ(2, counters.num_hierarchy_conflict_application_failures)
    925       << "The updates with unknown ancestors should be in conflict";
    926   EXPECT_EQ(4, counters.num_updates_applied)
    927       << "The updates with known ancestors should be successfully applied";
    928 
    929   {
    930     syncable::ReadTransaction trans(FROM_HERE, directory());
    931     syncable::Entry u1(&trans, syncable::GET_BY_HANDLE, u1_handle);
    932     syncable::Entry u2(&trans, syncable::GET_BY_HANDLE, u2_handle);
    933     syncable::Entry k1(&trans, syncable::GET_BY_HANDLE, k1_handle);
    934     syncable::Entry k2(&trans, syncable::GET_BY_HANDLE, k2_handle);
    935     syncable::Entry k3(&trans, syncable::GET_BY_HANDLE, k3_handle);
    936     syncable::Entry k4(&trans, syncable::GET_BY_HANDLE, k4_handle);
    937     ASSERT_TRUE(u1.good());
    938     ASSERT_TRUE(u2.good());
    939     ASSERT_TRUE(k1.good());
    940     ASSERT_TRUE(k2.good());
    941     ASSERT_TRUE(k3.good());
    942     ASSERT_TRUE(k4.good());
    943     EXPECT_TRUE(u1.GetIsUnappliedUpdate());
    944     EXPECT_TRUE(u2.GetIsUnappliedUpdate());
    945     EXPECT_FALSE(k1.GetIsUnappliedUpdate());
    946     EXPECT_FALSE(k2.GetIsUnappliedUpdate());
    947     EXPECT_FALSE(k3.GetIsUnappliedUpdate());
    948     EXPECT_FALSE(k4.GetIsUnappliedUpdate());
    949   }
    950 }
    951 
    952 // Attempt application of password upates where the passphrase is known.
    953 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, DecryptablePassword) {
    954   // Decryptable password updates should be applied.
    955   Cryptographer* cryptographer;
    956   {
    957     // Storing the cryptographer separately is bad, but for this test we
    958     // know it's safe.
    959     syncable::ReadTransaction trans(FROM_HERE, directory());
    960     cryptographer = directory()->GetCryptographer(&trans);
    961   }
    962 
    963   KeyParams params = {"localhost", "dummy", "foobar"};
    964   cryptographer->AddKey(params);
    965 
    966   sync_pb::EntitySpecifics specifics;
    967   sync_pb::PasswordSpecificsData data;
    968   data.set_origin("http://example.com");
    969 
    970   cryptographer->Encrypt(data,
    971                          specifics.mutable_password()->mutable_encrypted());
    972   int64 handle =
    973       entry_factory()->CreateUnappliedNewItem("item", specifics, false);
    974 
    975   sessions::StatusController status;
    976   ApplyPasswordUpdates(&status);
    977 
    978   const UpdateCounters& counters = GetPasswordsUpdateCounters();
    979   EXPECT_EQ(1, counters.num_updates_applied)
    980       << "The updates that can be decrypted should be applied";
    981 
    982   {
    983     syncable::ReadTransaction trans(FROM_HERE, directory());
    984     syncable::Entry e(&trans, syncable::GET_BY_HANDLE, handle);
    985     ASSERT_TRUE(e.good());
    986     EXPECT_FALSE(e.GetIsUnappliedUpdate());
    987     EXPECT_FALSE(e.GetIsUnsynced());
    988   }
    989 }
    990 
    991 // Attempt application of encrypted items when the passphrase is not known.
    992 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, UndecryptableData) {
    993   // Undecryptable updates should not be applied.
    994   sync_pb::EntitySpecifics encrypted_bookmark;
    995   encrypted_bookmark.mutable_encrypted();
    996   AddDefaultFieldValue(BOOKMARKS, &encrypted_bookmark);
    997   std::string root_server_id = syncable::GetNullId().GetServerId();
    998   int64 folder_handle = entry_factory()->CreateUnappliedNewItemWithParent(
    999       "folder",
   1000       encrypted_bookmark,
   1001       root_server_id);
   1002   int64 bookmark_handle = entry_factory()->CreateUnappliedNewItem(
   1003       "item2",
   1004       encrypted_bookmark,
   1005       false);
   1006   sync_pb::EntitySpecifics encrypted_password;
   1007   encrypted_password.mutable_password();
   1008   int64 password_handle = entry_factory()->CreateUnappliedNewItem(
   1009       "item3",
   1010       encrypted_password,
   1011       false);
   1012 
   1013   sessions::StatusController status;
   1014   ApplyBookmarkUpdates(&status);
   1015   ApplyPasswordUpdates(&status);
   1016 
   1017   const UpdateCounters& bm_counters = GetBookmarksUpdateCounters();
   1018   EXPECT_EQ(2, bm_counters.num_encryption_conflict_application_failures)
   1019       << "Updates that can't be decrypted should be in encryption conflict";
   1020   EXPECT_EQ(0, bm_counters.num_updates_applied)
   1021       << "No update that can't be decrypted should be applied";
   1022 
   1023   const UpdateCounters& pw_counters = GetPasswordsUpdateCounters();
   1024   EXPECT_EQ(1, pw_counters.num_encryption_conflict_application_failures)
   1025       << "Updates that can't be decrypted should be in encryption conflict";
   1026   EXPECT_EQ(0, pw_counters.num_updates_applied)
   1027       << "No update that can't be decrypted should be applied";
   1028 
   1029   {
   1030     syncable::ReadTransaction trans(FROM_HERE, directory());
   1031     syncable::Entry folder(&trans, syncable::GET_BY_HANDLE, folder_handle);
   1032     syncable::Entry bm(&trans, syncable::GET_BY_HANDLE, bookmark_handle);
   1033     syncable::Entry pw(&trans, syncable::GET_BY_HANDLE, password_handle);
   1034     ASSERT_TRUE(folder.good());
   1035     ASSERT_TRUE(bm.good());
   1036     ASSERT_TRUE(pw.good());
   1037     EXPECT_TRUE(folder.GetIsUnappliedUpdate());
   1038     EXPECT_TRUE(bm.GetIsUnappliedUpdate());
   1039     EXPECT_TRUE(pw.GetIsUnappliedUpdate());
   1040   }
   1041 }
   1042 
   1043 // Test a mix of decryptable and undecryptable updates.
   1044 TEST_F(DirectoryUpdateHandlerApplyUpdateTest, SomeUndecryptablePassword) {
   1045   Cryptographer* cryptographer;
   1046 
   1047   int64 decryptable_handle = -1;
   1048   int64 undecryptable_handle = -1;
   1049 
   1050   // Only decryptable password updates should be applied.
   1051   {
   1052     sync_pb::EntitySpecifics specifics;
   1053     sync_pb::PasswordSpecificsData data;
   1054     data.set_origin("http://example.com/1");
   1055     {
   1056       syncable::ReadTransaction trans(FROM_HERE, directory());
   1057       cryptographer = directory()->GetCryptographer(&trans);
   1058 
   1059       KeyParams params = {"localhost", "dummy", "foobar"};
   1060       cryptographer->AddKey(params);
   1061 
   1062       cryptographer->Encrypt(data,
   1063           specifics.mutable_password()->mutable_encrypted());
   1064     }
   1065     decryptable_handle =
   1066         entry_factory()->CreateUnappliedNewItem("item1", specifics, false);
   1067   }
   1068   {
   1069     // Create a new cryptographer, independent of the one in the session.
   1070     Cryptographer other_cryptographer(cryptographer->encryptor());
   1071     KeyParams params = {"localhost", "dummy", "bazqux"};
   1072     other_cryptographer.AddKey(params);
   1073 
   1074     sync_pb::EntitySpecifics specifics;
   1075     sync_pb::PasswordSpecificsData data;
   1076     data.set_origin("http://example.com/2");
   1077 
   1078     other_cryptographer.Encrypt(data,
   1079         specifics.mutable_password()->mutable_encrypted());
   1080     undecryptable_handle =
   1081         entry_factory()->CreateUnappliedNewItem("item2", specifics, false);
   1082   }
   1083 
   1084   sessions::StatusController status;
   1085   ApplyPasswordUpdates(&status);
   1086 
   1087   const UpdateCounters& counters = GetPasswordsUpdateCounters();
   1088   EXPECT_EQ(1, counters.num_encryption_conflict_application_failures)
   1089       << "The updates that can't be decrypted should be in encryption "
   1090       << "conflict";
   1091   EXPECT_EQ(1, counters.num_updates_applied)
   1092       << "The undecryptable password update shouldn't be applied";
   1093 
   1094   {
   1095     syncable::ReadTransaction trans(FROM_HERE, directory());
   1096     syncable::Entry e1(&trans, syncable::GET_BY_HANDLE, decryptable_handle);
   1097     syncable::Entry e2(&trans, syncable::GET_BY_HANDLE, undecryptable_handle);
   1098     ASSERT_TRUE(e1.good());
   1099     ASSERT_TRUE(e2.good());
   1100     EXPECT_FALSE(e1.GetIsUnappliedUpdate());
   1101     EXPECT_TRUE(e2.GetIsUnappliedUpdate());
   1102   }
   1103 }
   1104 
   1105 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
   1106        SimpleConflictDifferentAttachmentMetadata) {
   1107   const bool is_folder = false;
   1108   sync_pb::EntitySpecifics specifics;
   1109   *specifics.mutable_article() = sync_pb::ArticleSpecifics();
   1110   int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
   1111 
   1112   sync_pb::AttachmentIdProto local_attachment_id = CreateAttachmentIdProto();
   1113   sync_pb::AttachmentIdProto server_attachment_id = CreateAttachmentIdProto();
   1114 
   1115   // Add an attachment to the local attachment metadata.
   1116   sync_pb::AttachmentMetadata local_metadata;
   1117   sync_pb::AttachmentMetadataRecord* local_record = local_metadata.add_record();
   1118   *local_record->mutable_id() = local_attachment_id;
   1119   local_record->set_is_on_server(true);
   1120   entry_factory()->SetLocalAttachmentMetadataForItem(handle, local_metadata);
   1121 
   1122   // Add a different attachment to the server attachment metadata.
   1123   sync_pb::AttachmentMetadata server_metadata;
   1124   sync_pb::AttachmentMetadataRecord* server_record =
   1125       server_metadata.add_record();
   1126   *server_record->mutable_id() = server_attachment_id;
   1127   server_record->set_is_on_server(true);
   1128   entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata);
   1129 
   1130   // At this point we have a simple conflict.  The server says art1 should have
   1131   // server_attachment_id, but the local sync engine says it should have
   1132   // local_attachment_id.
   1133 
   1134   sessions::StatusController status;
   1135   ApplyArticlesUpdates(&status);
   1136 
   1137   // See that the server won.
   1138   const UpdateCounters& counters = GetArticlesUpdateCounters();
   1139   EXPECT_EQ(1, counters.num_updates_applied);
   1140   EXPECT_EQ(1, counters.num_local_overwrites);
   1141   EXPECT_EQ(0, counters.num_server_overwrites);
   1142   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   1143   EXPECT_EQ(server_metadata.SerializeAsString(),
   1144             local_metadata.SerializeAsString());
   1145 }
   1146 
   1147 TEST_F(DirectoryUpdateHandlerApplyUpdateTest,
   1148        SimpleConflictSameAttachmentMetadataDifferentOrder) {
   1149   const bool is_folder = false;
   1150   sync_pb::EntitySpecifics specifics;
   1151   *specifics.mutable_article() = sync_pb::ArticleSpecifics();
   1152   int64 handle = entry_factory()->CreateSyncedItem("art1", ARTICLES, is_folder);
   1153 
   1154   sync_pb::AttachmentIdProto id1 = CreateAttachmentIdProto();
   1155   sync_pb::AttachmentIdProto id2 = CreateAttachmentIdProto();
   1156 
   1157   // Add id1, then id2 to the local attachment metadata.
   1158   sync_pb::AttachmentMetadata local_metadata;
   1159   sync_pb::AttachmentMetadataRecord* record = local_metadata.add_record();
   1160   *record->mutable_id() = id1;
   1161   record->set_is_on_server(true);
   1162   record = local_metadata.add_record();
   1163   *record->mutable_id() = id2;
   1164   record->set_is_on_server(true);
   1165   entry_factory()->SetLocalAttachmentMetadataForItem(handle, local_metadata);
   1166 
   1167   // Add id1 and id2 to the server attachment metadata, but in reverse order.
   1168   sync_pb::AttachmentMetadata server_metadata;
   1169   record = server_metadata.add_record();
   1170   *record->mutable_id() = id2;
   1171   record->set_is_on_server(true);
   1172   record = local_metadata.add_record();
   1173   *record->mutable_id() = id1;
   1174   record->set_is_on_server(true);
   1175   entry_factory()->SetServerAttachmentMetadataForItem(handle, server_metadata);
   1176 
   1177   // At this point we have a (false) conflict.
   1178 
   1179   sessions::StatusController status;
   1180   ApplyArticlesUpdates(&status);
   1181 
   1182   // See that the server won.
   1183   const UpdateCounters& counters = GetArticlesUpdateCounters();
   1184   EXPECT_EQ(1, counters.num_updates_applied);
   1185   EXPECT_EQ(1, counters.num_local_overwrites);
   1186   EXPECT_EQ(0, counters.num_server_overwrites);
   1187   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   1188   EXPECT_EQ(server_metadata.SerializeAsString(),
   1189             local_metadata.SerializeAsString());
   1190 }
   1191 
   1192 }  // namespace syncer
   1193