Trim code from sync's ServerConnectionManager

sync/engine/net/server_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.
 
 #ifndef SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_
 #define SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_
 #pragma once
 
 #include <iosfwd>
 #include <string>
@@ skipping 42 matching lines @@
     SYNC_SERVER_ERROR,
 
     // SYNC_AUTH_ERROR is returned when the HTTP status code indicates that an
     // auth error has occured (i.e. a 401 or sync-specific AUTH_INVALID
     // response)
     // TODO(tim): Caring about AUTH_INVALID is a layering violation. But
     // this app-specific logic is being added as a stable branch hotfix so
     // minimal changes prevail for the moment.  Fix this! Bug 35060.
     SYNC_AUTH_ERROR,
 
-    // All the following connection codes are valid responses from the server.
-    // Means the server is up.  If you update this list, be sure to also update
-    // IsGoodReplyFromServer().
-
     // SERVER_CONNECTION_OK is returned when request was handled correctly.
     SERVER_CONNECTION_OK,
 
     // RETRY is returned when a Commit request fails with a RETRY response from
     // the server.
     //
     // TODO(idana): the server no longer returns RETRY so we should remove this
     // value.
     RETRY,
   };
@@ skipping 12 matching lines @@
 
   // Identifies the type of failure, if any.
   ServerConnectionCode server_status;
 
   HttpResponse();
 
   static const char* GetServerConnectionCodeString(
       ServerConnectionCode code);
 };
 
-inline bool IsGoodReplyFromServer(HttpResponse::ServerConnectionCode code) {
-  return code >= HttpResponse::SERVER_CONNECTION_OK;
-}
-
 struct ServerConnectionEvent {
   HttpResponse::ServerConnectionCode connection_code;
-  bool server_reachable;
-  ServerConnectionEvent(HttpResponse::ServerConnectionCode code,
-                         bool server_reachable) :
-      connection_code(code), server_reachable(server_reachable) {}
+  explicit ServerConnectionEvent(HttpResponse::ServerConnectionCode code) :
+      connection_code(code) {}
 };
 
 class ServerConnectionEventListener {
  public:
   virtual void OnServerConnectionEvent(const ServerConnectionEvent& event) = 0;
  protected:
   virtual ~ServerConnectionEventListener() {}
 };
 
 class ServerConnectionManager;
 // A helper class that automatically notifies when the status changes.
 // TODO(tim): This class shouldn't be exposed outside of the implementation,
 // bug 35060.
 class ScopedServerStatusWatcher : public base::NonThreadSafe {
  public:
   ScopedServerStatusWatcher(ServerConnectionManager* conn_mgr,
                             HttpResponse* response);
   virtual ~ScopedServerStatusWatcher();
  private:
   ServerConnectionManager* const conn_mgr_;
   HttpResponse* const response_;
-  bool server_reachable_;
   DISALLOW_COPY_AND_ASSIGN(ScopedServerStatusWatcher);
 };
 
 // Use this class to interact with the sync server.
 // The ServerConnectionManager currently supports POSTing protocol buffers.
 //
 class ServerConnectionManager {
  public:
   // buffer_in - will be POSTed
   // buffer_out - string will be overwritten with response
@@ skipping 53 matching lines @@
 
   virtual ~ServerConnectionManager();
 
   // POSTS buffer_in and reads a response into buffer_out. Uses our currently
   // set auth token in our headers.
   //
   // Returns true if executed successfully.
   virtual bool PostBufferWithCachedAuth(PostBufferParams* params,
                                         ScopedServerStatusWatcher* watcher);
 
-  // Checks the time on the server. Returns false if the request failed. |time|
-  // is an out parameter that stores the value returned from the server.
-  virtual bool CheckTime(int32* out_time);
-
-  // Returns true if sync_server_ is reachable. This method verifies that the
-  // server is pingable and that traffic can be sent to and from it.
-  virtual bool IsServerReachable();
-
-  // Returns true if user has been successfully authenticated.
-  virtual bool IsUserAuthenticated();
-
-  // Updates status and broadcasts events on change.
-  bool CheckServerReachable();
-
   void AddListener(ServerConnectionEventListener* listener);
   void RemoveListener(ServerConnectionEventListener* listener);
 
   inline std::string user_agent() const { return user_agent_; }
 
   inline HttpResponse::ServerConnectionCode server_status() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return server_status_;
   }
 
-  inline bool server_reachable() const { return server_reachable_; }
-
   const std::string client_id() const { return client_id_; }
 
-  // This changes the server info used by the connection manager. This allows
-  // a single client instance to talk to different backing servers. This is
-  // typically called during / after authentication so that the server url
-  // can be a function of the user's login id.
-  void SetServerParameters(const std::string& server_url,
-                           int port,
-                           bool use_ssl);
-
   // Returns the current server parameters in server_url, port and use_ssl.
   void GetServerParameters(std::string* server_url,
                            int* port,
                            bool* use_ssl) const;
 
   std::string GetServerHost() const;
 
   // Factory method to create an Connection object we can use for
   // communication with the server.
   virtual Connection* MakeConnection();
@@ skipping 23 matching lines @@
 
   void InvalidateAndClearAuthToken() {
     DCHECK(thread_checker_.CalledOnValidThread());
     // Copy over the token to previous invalid token.
     if (!auth_token_.empty()) {
       previously_invalidated_token.assign(auth_token_);
       auth_token_ = std::string();
     }
   }
 
+  bool HasInvalidAuthToken() {
+    return auth_token_.empty();
+  }
+
   const std::string auth_token() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return auth_token_;
   }
 
  protected:
   inline std::string proto_sync_path() const {
     return proto_sync_path_;
   }
 
@@ skipping 30 matching lines @@
   // The user-agent string for HTTP.
   std::string user_agent_;
 
   // Indicates whether or not requests should be made using HTTPS.
   bool use_ssl_;
 
   // The paths we post to.
   std::string proto_sync_path_;
   std::string get_time_path_;
 
-  // The auth token to use in authenticated requests. Set by the AuthWatcher.
+  // The auth token to use in authenticated requests.
   std::string auth_token_;
 
   // The previous auth token that is invalid now.
   std::string previously_invalidated_token;
 
   ObserverList<ServerConnectionEventListener> listeners_;
 
   HttpResponse::ServerConnectionCode server_status_;
-  bool server_reachable_;
 
   base::ThreadChecker thread_checker_;
 
   // Protects all variables below to allow bailing out of active connections.
   base::Lock terminate_connection_lock_;
 
   // If true, we've been told to terminate IO and expect to be destroyed
   // shortly.  No future network requests will be made.
   bool terminated_;
 
@@ skipping 31 matching lines @@
 // settings.
 bool FillMessageWithShareDetails(sync_pb::ClientToServerMessage* csm,
                                  syncable::Directory* manager,
                                  const std::string& share);
 
 std::ostream& operator<<(std::ostream& s, const struct HttpResponse& hr);
 
 }  // namespace browser_sync
 
 #endif  // SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_