[Sync] Add support for performing a GetKey on startup.

sync/engine/syncer_unittest.cc

 // Copyright (c) 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 170 matching lines @@
         ModelSafeRoutingInfoToPayloadMap(info, std::string());
     return new SyncSession(context_.get(), this,
         sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN, types),
         info, workers);
   }
 
   bool SyncShareAsDelegate(
       SyncScheduler::SyncSessionJob::SyncSessionJobPurpose purpose) {
     SyncerStep start;
     SyncerStep end;
-    SyncScheduler::SetSyncerStepsForPurpose(purpose, &start, &end);
+    SyncScheduler::SetSyncerStepsForPurpose(purpose,
+                                            &start,
+                                            &end);
 
     session_.reset(MakeSession());
     syncer_->SyncShare(session_.get(), start, end);
     return session_->HasMoreToSync();
   }
 
   bool SyncShareNudge() {
     session_.reset(MakeSession());
     return SyncShareAsDelegate(SyncScheduler::SyncSessionJob::NUDGE);
   }
@@ skipping 28 matching lines @@
 
     GetModelSafeRoutingInfo(&routing_info);
     GetWorkers(&workers);
 
     throttled_data_type_tracker_.reset(new ThrottledDataTypeTracker(NULL));
 
     context_.reset(
         new SyncSessionContext(
             mock_server_.get(), directory(), routing_info, workers,
             &extensions_activity_monitor_, throttled_data_type_tracker_.get(),
-            listeners, NULL, &traffic_recorder_));
+            listeners, NULL, &traffic_recorder_,
+            true  /* enable keystore encryption */));
     ASSERT_FALSE(context_->resolver());
     syncer_ = new Syncer();
     session_.reset(MakeSession());
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Directory::ChildHandles 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() {
     mock_server_.reset();
     delete syncer_;
     syncer_ = NULL;
     dir_maker_.TearDown();
   }
   void WriteTestDataToEntry(WriteTransaction* trans, MutableEntry* entry) {
     EXPECT_FALSE(entry->Get(IS_DIR));
@@ skipping 2036 matching lines @@
     MutableEntry entry2(&trans, syncable::CREATE, bob.Get(syncable::ID),
                         "bob");
     CHECK(entry2.good());
     entry2.Put(syncable::IS_DIR, true);
     entry2.Put(syncable::IS_UNSYNCED, true);
     entry2.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 };
 
 TEST_F(EntryCreatedInNewFolderTest, EntryCreatedInNewFolderMidSync) {
-  directory()->set_store_birthday(mock_server_->store_birthday());
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, syncable::CREATE, trans.root_id(),
                        "bob");
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 
@@ skipping 1839 matching lines @@
   // The second node was not downloaded.
   Entry n2(&trans, GET_BY_ID, node2);
   EXPECT_FALSE(n2.good());
 
   // One update remains undownloaded.
   mock_server_->ClearUpdatesQueue();
 
   EXPECT_FALSE(initial_sync_ended_for_type(syncer::BOOKMARKS));
 }
 
+TEST_F(SyncerTest, GetKeySuccess) {
+  {
+    syncable::ReadTransaction rtrans(FROM_HERE, directory());
+    EXPECT_FALSE(cryptographer(&rtrans)->HasKeystoreKey());
+  }
+
+  SyncShareConfigure();
+
+  EXPECT_EQ(session_->status_controller().last_get_key_result(), SYNCER_OK);
+  {
+    syncable::ReadTransaction rtrans(FROM_HERE, directory());
+    EXPECT_TRUE(cryptographer(&rtrans)->HasKeystoreKey());
+  }
+}
+
+TEST_F(SyncerTest, GetKeyEmpty) {
+  {
+    syncable::ReadTransaction rtrans(FROM_HERE, directory());
+    EXPECT_FALSE(cryptographer(&rtrans)->HasKeystoreKey());
+  }
+
+  mock_server_->SetKeystoreKey("");
+  SyncShareConfigure();
+
+  EXPECT_NE(session_->status_controller().last_get_key_result(), SYNCER_OK);
+  {
+    syncable::ReadTransaction rtrans(FROM_HERE, directory());
+    EXPECT_FALSE(cryptographer(&rtrans)->HasKeystoreKey());
+  }
+}
+
 // Test what happens if a client deletes, then recreates, an object very
 // quickly.  It is possible that the deletion gets sent as a commit, and
 // the undelete happens during the commit request.  The principle here
 // is that with a single committing client, conflicts should never
 // be encountered, and a client encountering its past actions during
 // getupdates should never feed back to override later actions.
 //
 // In cases of ordering A-F below, the outcome should be the same.
 //   Exercised by UndeleteDuringCommit:
 //     A. Delete - commit - undelete - commitresponse.
@@ skipping 644 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace syncer