[Sync] Remove ScopedServerStatusWatcher

sync/engine/net/server_connection_manager.h

 // Copyright 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_
 
 #include <iosfwd>
 #include <string>
 
@@ skipping 88 matching lines @@
       connection_code(code) {}
 };
 
 class SYNC_EXPORT_PRIVATE 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 SYNC_EXPORT_PRIVATE ScopedServerStatusWatcher
-    : public base::NonThreadSafe {
- public:
-  ScopedServerStatusWatcher(ServerConnectionManager* conn_mgr,
-                            HttpResponse* response);
-  virtual ~ScopedServerStatusWatcher();
- private:
-  ServerConnectionManager* const conn_mgr_;
-  HttpResponse* const response_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedServerStatusWatcher);
-};
-
 // Use this class to interact with the sync server.
 // The ServerConnectionManager currently supports POSTing protocol buffers.
 //
 class SYNC_EXPORT_PRIVATE ServerConnectionManager : public CancelationObserver {
  public:
   // buffer_in - will be POSTed
   // buffer_out - string will be overwritten with response
   struct PostBufferParams {
     std::string buffer_in;
     std::string buffer_out;
@@ skipping 47 matching lines @@
                           int port,
                           bool use_ssl,
                           CancelationSignal* cancelation_signal);
 
   ~ServerConnectionManager() override;
 
   // 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);
+  virtual bool PostBufferWithCachedAuth(PostBufferParams* params);
 
   void AddListener(ServerConnectionEventListener* listener);
   void RemoveListener(ServerConnectionEventListener* listener);
 
   inline HttpResponse::ServerConnectionCode server_status() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return server_status_;
   }
 
   const std::string client_id() const { return client_id_; }
@@ skipping 39 matching lines @@
   }
 
   // Updates server_status_ and notifies listeners if server_status_ changed
   void SetServerStatus(HttpResponse::ServerConnectionCode server_status);
 
   // NOTE: Tests rely on this protected function being virtual.
   //
   // Internal PostBuffer base function.
   virtual bool PostBufferToPath(PostBufferParams*,
                                 const std::string& path,
-                                const std::string& auth_token,
-                                ScopedServerStatusWatcher* watcher);
+                                const std::string& auth_token);
 
   // An internal helper to clear our auth_token_ and cache the old version
   // in |previously_invalidated_token_| to shelter us from retrying with a
   // known bad token.
   void InvalidateAndClearAuthToken();
 
   // Helper to check terminated flags and build a Connection object, installing
   // it as the |active_connection_|.  If this ServerConnectionManager has been
   // terminated, this will return NULL.
   Connection* MakeActiveConnection();
@@ skipping 35 matching lines @@
   // If true, we've been told to terminate IO and expect to be destroyed
   // shortly.  No future network requests will be made.
   bool terminated_;
 
   // A non-owning pointer to any active http connection, so that we can abort
   // it if necessary.
   Connection* active_connection_;
 
  private:
   friend class Connection;
-  friend class ScopedServerStatusWatcher;
 
   // A class to help deal with cleaning up active Connection objects when (for
   // ex) multiple early-exits are present in some scope. ScopedConnectionHelper
   // informs the ServerConnectionManager before the Connection object it takes
   // ownership of is destroyed.
   class ScopedConnectionHelper {
    public:
     // |manager| must outlive this. Takes ownership of |connection|.
     ScopedConnectionHelper(ServerConnectionManager* manager,
                            Connection* connection);
@@ skipping 11 matching lines @@
   bool signal_handler_registered_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerConnectionManager);
 };
 
 std::ostream& operator<<(std::ostream& s, const struct HttpResponse& hr);
 
 }  // namespace syncer
 
 #endif  // SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_