New authorization framework for sync. ...

chrome/browser/sync/engine/net/server_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.
 
 #ifndef CHROME_BROWSER_SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_
 #define CHROME_BROWSER_SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_
 #pragma once
 
 #include <iosfwd>
 #include <string>
@@ skipping 195 matching lines @@
     int ReadResponse(void* buffer, int length);
     int ReadResponse(std::string* buffer, int length);
     RequestTimingInfo* timing_info_;
   };
 
   // The lifetime of the GaiaAuthenticator must be longer than the instance
   // of the ServerConnectionManager that you're creating.
   ServerConnectionManager(const std::string& server,
                           int port,
                           bool use_ssl,
-                          const std::string& user_agent,
-                          const std::string& client_id);
+                          const std::string& user_agent);
 
   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(const PostBufferParams* params,
                                         ScopedServerStatusWatcher* watcher);
 
-  // POSTS buffer_in and reads a response into buffer_out. Add a specific auth
-  // token to http headers.
-  //
-  // Returns true if executed successfully.
-  virtual bool PostBufferWithAuth(const PostBufferParams* params,
-                                  const std::string& auth_token,
-                                  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();
@@ skipping 36 matching lines @@
     AutoLock lock(terminate_all_io_mutex_);
     return terminate_all_io_;
   }
 
   // Factory method to create a Post object we can use for communication with
   // the server.
   virtual Post* MakePost() {
     return NULL;  // For testing.
   };
 
+  void set_client_id(const std::string& client_id) {
+    DCHECK(client_id_.empty());
+    client_id_.assign(client_id);
+  }
+
   void set_auth_token(const std::string& auth_token) {
     // TODO(chron): Consider adding a message loop check here.
     AutoLock lock(auth_token_mutex_);
     auth_token_.assign(auth_token);
   }
 
   const std::string auth_token() const {
     AutoLock lock(auth_token_mutex_);
     return auth_token_;
   }
@@ skipping 24 matching lines @@
   // Protects access to sync_server_, sync_server_port_ and use_ssl_:
   mutable Lock server_parameters_mutex_;
 
   // The sync_server_ is the server that requests will be made to.
   std::string sync_server_;
 
   // The sync_server_port_ is the port that HTTP requests will be made on.
   int sync_server_port_;
 
   // The unique id of the user's client.
-  const std::string client_id_;
+  std::string client_id_;
 
   // 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.
   mutable Lock path_mutex_;
   std::string proto_sync_path_;
@@ skipping 33 matching lines @@
 bool FillMessageWithShareDetails(sync_pb::ClientToServerMessage* csm,
                                  syncable::DirectoryManager* manager,
                                  const std::string& share);
 
 }  // namespace browser_sync
 
 std::ostream& operator<<(std::ostream& s,
     const struct browser_sync::HttpResponse& hr);
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_