Use OAuth2 token for sync

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 146 matching lines @@
                             bool require_response);
     bool ReadDownloadResponse(HttpResponse* response, std::string* buffer_out);
 
    protected:
     std::string MakeConnectionURL(const std::string& sync_server,
                                   const std::string& path,
                                   bool use_ssl) const;
 
     void GetServerParams(std::string* server,
                          int* server_port,
-                         bool* use_ssl) const {
+                         bool* use_ssl,
+                         bool* use_oauth2_token) const {
       server->assign(scm_->sync_server_);
       *server_port = scm_->sync_server_port_;
       *use_ssl = scm_->use_ssl_;
+      *use_oauth2_token = scm_->use_oauth2_token_;
     }
 
     std::string buffer_;
     ServerConnectionManager* scm_;
 
    private:
     int ReadResponse(void* buffer, int length);
     int ReadResponse(std::string* buffer, int length);
   };
 
   ServerConnectionManager(const std::string& server,
                           int port,
-                          bool use_ssl);
+                          bool use_ssl,
+                          bool use_oauth2_token);
 
   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);
 
@@ skipping 23 matching lines @@
   // ThreadChecker thread, as we want to kill any pending http traffic without
   // having to wait for the request to complete.
   void TerminateAllIO();
 
   void set_client_id(const std::string& client_id) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(client_id_.empty());
     client_id_.assign(client_id);
   }
 
-  // Sets a new auth token and time. |auth_token_time| is an optional parameter
-  // that contains the date the auth token was fetched/refreshed, and is used
-  // for histogramms/logging only.
-  bool SetAuthToken(const std::string& auth_token,
-                    const base::Time& auth_token_time);
+  // Sets a new auth token and time.
+  bool SetAuthToken(const std::string& auth_token);
 
   // Our out-of-band invalidations channel can encounter auth errors,
   // and when it does so it tells us via this method to prevent making more
   // requests with known-bad tokens. This will put the
   // ServerConnectionManager in an auth error state as if it received an
   // HTTP 401 from sync servers.
   void OnInvalidationCredentialsRejected();
 
   bool HasInvalidAuthToken() {
     return auth_token_.empty();
@@ skipping 39 matching lines @@
 
   // 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.
   std::string client_id_;
 
   // Indicates whether or not requests should be made using HTTPS.
   bool use_ssl_;
 
+  // Indicates if token should be handled as OAuth2 token. Connection should set
+  // auth header appropriately.
+  // TODO(pavely): Remove once sync on android switches to oauth2 tokens.
+  bool use_oauth2_token_;
+
   // The paths we post to.
   std::string proto_sync_path_;
 
   // The auth token to use in authenticated requests.
   std::string auth_token_;
 
-  // The time at which this auth token was last created/refreshed.
-  // Used for histogramming.
-  base::Time auth_token_time_;
-
   // The previous auth token that is invalid now.
   std::string previously_invalidated_token;
 
   ObserverList<ServerConnectionEventListener> listeners_;
 
   HttpResponse::ServerConnectionCode server_status_;
 
   base::ThreadChecker thread_checker_;
 
   // Protects all variables below to allow bailing out of active connections.
@@ skipping 31 matching lines @@
   void NotifyStatusChanged();
 
   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_