[Sync] Remove now-obsolete FastDump class

chrome/test/sync/engine/mock_connection_manager.h

 // Copyright (c) 2010 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 CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #pragma once
 
@@ skipping 25 matching lines @@
 
    protected:
     virtual ~MidCommitObserver() {}
   };
 
   MockConnectionManager(syncable::DirectoryManager* dirmgr,
                         const std::string& name);
   virtual ~MockConnectionManager();
 
   // Overridden ServerConnectionManager functions.
-  virtual bool PostBufferToPath(const PostBufferParams*,
-      const string& path,
-      const string& auth_token,
+  virtual bool PostBufferToPath(
+      const PostBufferParams*,
+      const std::string& path,
+      const std::string& auth_token,
       browser_sync::ScopedServerStatusWatcher* watcher);
 
   virtual bool IsServerReachable();
   virtual bool IsUserAuthenticated();
 
   // Control of commit response.
   void SetMidCommitCallback(Callback0::Type* 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(string prepend);
+  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.
   // The SyncEntity returned is only valid until the Sync is completed
   // (e.g. with SyncShare.) It allows to add further entity properties before
   // sync, using SetLastXXX() methods and/or GetMutableLastUpdate().
   sync_pb::SyncEntity* AddUpdateDirectory(syncable::Id id,
                                           syncable::Id parent_id,
-                                          string name,
+                                          std::string name,
                                           int64 version,
                                           int64 sync_ts);
   sync_pb::SyncEntity* AddUpdateBookmark(syncable::Id id,
                                          syncable::Id parent_id,
-                                         string name,
+                                         std::string name,
                                          int64 version,
                                          int64 sync_ts);
   // Versions of the AddUpdate functions that accept integer IDs.
   sync_pb::SyncEntity* AddUpdateDirectory(int id,
                                           int parent_id,
-                                          string name,
+                                          std::string name,
                                           int64 version,
                                           int64 sync_ts);
   sync_pb::SyncEntity* AddUpdateBookmark(int id,
                                          int parent_id,
-                                         string name,
+                                         std::string name,
                                          int64 version,
                                          int64 sync_ts);
   // New protocol versions of the AddUpdate functions.
-  sync_pb::SyncEntity* AddUpdateDirectory(string id,
-                                          string parent_id,
-                                          string name,
+  sync_pb::SyncEntity* AddUpdateDirectory(std::string id,
+                                          std::string parent_id,
+                                          std::string name,
                                           int64 version,
                                           int64 sync_ts);
-  sync_pb::SyncEntity* AddUpdateBookmark(string id,
-                                         string parent_id,
-                                         string name,
+  sync_pb::SyncEntity* AddUpdateBookmark(std::string id,
+                                         std::string parent_id,
+                                         std::string name,
                                          int64 version,
                                          int64 sync_ts);
 
   // Find the last commit sent by the client, and replay it for the next get
   // updates command.  This can be used to simulate the GetUpdates that happens
   // immediately after a successful commit.
   sync_pb::SyncEntity* AddUpdateFromLastCommit();
 
   // Add a deleted item.  Deletion records typically contain no
   // additional information beyond the deletion, and no specifics.
   // The server may send the originator fields.
   void AddUpdateTombstone(const syncable::Id& id);
 
   void SetLastUpdateDeleted();
-  void SetLastUpdateServerTag(const string& tag);
-  void SetLastUpdateClientTag(const string& tag);
-  void SetLastUpdateOriginatorFields(const string& client_id,
-                                     const string& entry_id);
+  void SetLastUpdateServerTag(const std::string& tag);
+  void SetLastUpdateClientTag(const std::string& tag);
+  void SetLastUpdateOriginatorFields(const std::string& client_id,
+                                     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.
@@ skipping 56 matching lines @@
     next_new_id_ = value;
   }
   void set_conflict_n_commits(int value) {
     conflict_n_commits_ = value;
   }
 
   void set_use_legacy_bookmarks_protocol(bool value) {
     use_legacy_bookmarks_protocol_ = value;
   }
 
-  void set_store_birthday(string new_birthday) {
+  void set_store_birthday(std::string new_birthday) {
     // Multiple threads can set store_birthday_ in our tests, need to lock it to
     // ensure atomic read/writes and avoid race conditions.
     base::AutoLock lock(store_birthday_lock_);
     store_birthday_ = new_birthday;
   }
 
   // Retrieve the number of GetUpdates requests that the mock server has
   // seen since the last time this function was called.  Can be used to
   // verify that a GetUpdates actually did or did not happen after running
   // the syncer.
@@ skipping 19 matching lines @@
   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,
-                                     string name, int64 version,
+                                     std::string name, int64 version,
                                      int64 sync_ts,
                                      bool is_dir);
-  sync_pb::SyncEntity* AddUpdateFull(string id, string parentid, string name,
+  sync_pb::SyncEntity* AddUpdateFull(std::string id,
+                                     std::string parentid, std::string name,
                                      int64 version, int64 sync_ts,
                                      bool is_dir);
   // 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);
@@ skipping 32 matching lines @@
   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_;
 
   // The next id the mock will return to a commit.
   int next_new_id_;
 
   // The store birthday we send to the client.
-  string store_birthday_;
+  std::string store_birthday_;
   base::Lock store_birthday_lock_;
   bool store_birthday_sent_;
   bool client_stuck_;
-  string commit_time_rename_prepended_string_;
+  std::string commit_time_rename_prepended_string_;
 
   // Fail on the next call to PostBufferToPath().
   bool fail_next_postbuffer_;
 
   // Our directory.
   syncable::DirectoryManager* directory_manager_;
   std::string directory_name_;
 
   // The updates we'll return to the next request.
   std::list<sync_pb::GetUpdatesResponse> update_queue_;
@@ skipping 38 matching lines @@
   int num_get_updates_requests_;
 
   std::string next_token_;
 
   sync_pb::ClientToServerMessage last_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 #endif  // CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_