Trim code from sync's ServerConnectionManager

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_
 #pragma once
 
@@ skipping 23 matching lines @@
   explicit MockConnectionManager(syncable::Directory*);
   virtual ~MockConnectionManager();
 
   // Overridden ServerConnectionManager functions.
   virtual bool PostBufferToPath(
       PostBufferParams*,
       const std::string& path,
       const std::string& auth_token,
       browser_sync::ScopedServerStatusWatcher* watcher) OVERRIDE;
 
-  virtual bool IsServerReachable() OVERRIDE;
-  virtual bool IsUserAuthenticated() OVERRIDE;
-
   // Control of commit response.
   void SetMidCommitCallback(const base::Closure& callback);
   void SetMidCommitObserver(MidCommitObserver* observer);
 
   // Set this if you want commit to perform commit time rename. Will request
   // that the client renames all commited entries, prepending this string.
   void SetCommitTimeRename(std::string prepend);
 
   // Generic versions of AddUpdate functions. Tests using these function should
   // compile for both the int64 and string id based versions of the server.
@@ skipping 56 matching lines @@
                                      const std::string& entry_id);
   void SetLastUpdatePosition(int64 position_in_parent);
   void SetNewTimestamp(int ts);
   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();
 
-  // For AUTHENTICATE responses.
-  void SetAuthenticationResponseInfo(const std::string& valid_auth_token,
-                                     const std::string& user_display_name,
-                                     const std::string& user_display_email,
-                                     const std::string& user_obfuscated_id);
-
   void FailNextPostBufferToPathCall() { fail_next_postbuffer_ = true; }
 
   void SetClearUserDataResponseStatus(sync_pb::SyncEnums::ErrorType errortype);
 
   // A visitor class to allow a test to change some monitoring state atomically
   // with the action of overriding the response codes sent back to the Syncer
   // (for example, so you can say "ThrottleNextRequest, and assert no more
   // requests are made once throttling is in effect" in one step.
   class ResponseCodeOverrideRequestor {
    public:
@@ skipping 73 matching lines @@
 
   void ExpectGetUpdatesRequestPayloads(
       const syncable::ModelTypePayloadMap& payloads) {
     expected_payloads_ = payloads;
   }
 
   void SetServerReachable();
 
   void SetServerNotReachable();
 
+  // Updates our internal state as if we had attempted a connection.  Does not
+  // send notifications as a real connection attempt would.  This is useful in
+  // cases where we're mocking out most of the code that performs network
+  // requests.
+  void UpdateConnectionStatus();
+
   // Return by copy to be thread-safe.
   const std::string store_birthday() {
     base::AutoLock lock(store_birthday_lock_);
     return store_birthday_;
   }
 
   // Locate the most recent update message for purpose of alteration.
   sync_pb::SyncEntity* GetMutableLastUpdate();
 
  private:
   sync_pb::SyncEntity* AddUpdateFull(syncable::Id id, syncable::Id parentid,
                                      std::string name, int64 version,
                                      int64 sync_ts,
                                      bool is_dir);
   sync_pb::SyncEntity* AddUpdateFull(std::string id,
                                      std::string parentid, std::string name,
                                      int64 version, int64 sync_ts,
                                      bool is_dir);
   sync_pb::SyncEntity* AddUpdateMeta(std::string id, std::string parentid,
                                     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 ProcessAuthenticate(sync_pb::ClientToServerMessage* csm,
-                           sync_pb::ClientToServerResponse* response,
-                           const std::string& auth_token);
   void ProcessCommit(sync_pb::ClientToServerMessage* csm,
                      sync_pb::ClientToServerResponse* response_buffer);
   void ProcessClearData(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
@@ skipping 14 matching lines @@
   bool IsModelTypePresentInSpecifics(
       const google::protobuf::RepeatedPtrField<
           sync_pb::DataTypeProgressMarker>& filter,
       syncable::ModelType value);
 
   sync_pb::DataTypeProgressMarker const* GetProgressMarkerForType(
       const google::protobuf::RepeatedPtrField<
           sync_pb::DataTypeProgressMarker>& filter,
       syncable::ModelType value);
 
+  // When false, we pretend to have network connectivity issues.
+  bool server_reachable_;
+
   // All IDs that have been committed.
   std::vector<syncable::Id> committed_ids_;
 
   // Control of when/if we return conflicts.
   bool conflict_all_commits_;
   int conflict_n_commits_;
 
   // Commit messages we've sent, and responses we've returned.
   ScopedVector<sync_pb::CommitMessage> commit_messages_;
   ScopedVector<sync_pb::CommitResponse> commit_responses_;
@@ skipping 60 matching lines @@
   int num_get_updates_requests_;
 
   std::string next_token_;
 
   sync_pb::ClientToServerMessage last_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 #endif  // SYNC_TEST_ENGINE_MOCK_CONNECTION_MANAGER_H_