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

sync/test/engine/mock_connection_manager.h

 // 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.
 //
 // Mock ServerConnectionManager class for use in client unit tests.
 
 #ifndef SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_
 
 #include <bitset>
@@ skipping 104 matching lines @@
   void SetChangesRemaining(int64 count);
 
   // Add a new batch of updates after the current one.  Allows multiple
   // GetUpdates responses to be buffered up, since the syncer may
   // issue multiple requests during a sync cycle.
   void NextUpdateBatch();
 
   void FailNextPostBufferToPathCall() { countdown_to_postbuffer_fail_ = 1; }
   void FailNthPostBufferToPathCall(int n) { countdown_to_postbuffer_fail_ = n; }
 
+  void SetKeystoreKey(const std::string& key);
+  void SetGetKeyResponseStatus(sync_pb::SyncEnums::ErrorType errortype);
+
   void FailNonPeriodicGetUpdates() { fail_non_periodic_get_updates_ = true; }
 
   // Simple inspectors.
   bool client_stuck() const { return client_stuck_; }
 
   sync_pb::ClientCommand* GetNextClientCommand();
 
   const std::vector<syncable::Id>& committed_ids() const {
     return committed_ids_;
   }
@@ skipping 94 matching lines @@
                                     std::string name, int64 version,
                                     int64 sync_ts);
 
   // Functions to handle the various types of server request.
   void ProcessGetUpdates(sync_pb::ClientToServerMessage* csm,
                          sync_pb::ClientToServerResponse* response);
   void ProcessCommit(sync_pb::ClientToServerMessage* csm,
                      sync_pb::ClientToServerResponse* response_buffer);
   void ProcessClearData(sync_pb::ClientToServerMessage* csm,
                         sync_pb::ClientToServerResponse* response);
+  void ProcessGetKey(sync_pb::ClientToServerMessage* csm,
+                     sync_pb::ClientToServerResponse* response);
   void AddDefaultBookmarkData(sync_pb::SyncEntity* entity, bool is_folder);
 
   // Determine if one entry in a commit should be rejected with a conflict.
   bool ShouldConflictThisCommit();
 
   // Generate a numeric position_in_parent value.  We use a global counter
   // that only decreases; this simulates new objects always being added to the
   // front of the ordering.
   int64 GeneratePositionInParent() {
     return next_position_in_parent_--;
@@ skipping 51 matching lines @@
   syncable::Directory* directory_;
 
   // The updates we'll return to the next request.
   std::list<sync_pb::GetUpdatesResponse> update_queue_;
   base::Closure mid_commit_callback_;
   MidCommitObserver* mid_commit_observer_;
 
   // The clear data response we'll return in the next response
   sync_pb::SyncEnums::ErrorType clear_user_data_response_errortype_;
 
+  // The keystore key we return in a GetKey response.
+  std::string keystore_key_;
+  // The GetKey response we'll next return.
+  sync_pb::SyncEnums::ErrorType get_key_response_errortype_;
+
   // The AUTHENTICATE response we'll return for auth requests.
   sync_pb::AuthenticateResponse auth_response_;
   // What we use to determine if we should return SUCCESS or BAD_AUTH_TOKEN.
   std::string valid_auth_token_;
 
   // Whether we are faking a server mandating clients to throttle requests.
   // Protected by |response_code_override_lock_|.
   bool throttling_;
 
   // Whether we are failing all requests by returning
@@ skipping 25 matching lines @@
   std::string next_token_;
 
   sync_pb::ClientToServerMessage last_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_