Use OAuth2 token for sync

sync/engine/net/server_connection_manager.cc

 // 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.
 
 #include "sync/engine/net/server_connection_manager.h"
 
 #include <errno.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
-#include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
 #include "sync/engine/net/url_translator.h"
 #include "sync/engine/syncer.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h"
 
@@ skipping 146 matching lines @@
   response->server_status = conn_mgr->server_status_;
 }
 
 ScopedServerStatusWatcher::~ScopedServerStatusWatcher() {
   conn_mgr_->SetServerStatus(response_->server_status);
 }
 
 ServerConnectionManager::ServerConnectionManager(
     const string& server,
     int port,
-    bool use_ssl)
+    bool use_ssl,
+    bool use_oauth2_token)
     : sync_server_(server),
       sync_server_port_(port),
       use_ssl_(use_ssl),
+      use_oauth2_token_(use_oauth2_token),
       proto_sync_path_(kSyncServerSyncPath),
       server_status_(HttpResponse::NONE),
       terminated_(false),
       active_connection_(NULL) {
 }
 
 ServerConnectionManager::~ServerConnectionManager() {
 }
 
 ServerConnectionManager::Connection*
@@ skipping 12 matching lines @@
   base::AutoLock lock(terminate_connection_lock_);
   // |active_connection_| can be NULL already if it was aborted. Also,
   // it can legitimately be a different Connection object if a new Connection
   // was created after a previous one was Aborted and destroyed.
   if (active_connection_ != connection)
     return;
 
   active_connection_ = NULL;
 }
 
-bool ServerConnectionManager::SetAuthToken(const std::string& auth_token,
-                                           const base::Time& auth_token_time) {
+bool ServerConnectionManager::SetAuthToken(const std::string& auth_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (previously_invalidated_token != auth_token) {
     auth_token_.assign(auth_token);
-    auth_token_time_ = auth_token_time;
     previously_invalidated_token = std::string();
     return true;
   }
   return false;
 }
 
 void ServerConnectionManager::OnInvalidationCredentialsRejected() {
-  if (!auth_token_time_.is_null()) {
-    base::TimeDelta age = base::Time::Now() - auth_token_time_;
-    if (age < base::TimeDelta::FromHours(1)) {
-      UMA_HISTOGRAM_CUSTOM_TIMES("Sync.AuthInvalidationRejectedTokenAgeShort",
-                                 age,
-                                 base::TimeDelta::FromSeconds(1),
-                                 base::TimeDelta::FromHours(1),
-                                 50);
-    }
-    UMA_HISTOGRAM_COUNTS("Sync.AuthInvalidationRejectedTokenAgeLong",
-                         age.InDays());
-  }
   InvalidateAndClearAuthToken();
   SetServerStatus(HttpResponse::SYNC_AUTH_ERROR);
 }
 
 void ServerConnectionManager::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();
-    auth_token_time_ = base::Time();
   }
 }
 
 void ServerConnectionManager::SetServerStatus(
     HttpResponse::ServerConnectionCode server_status) {
   if (server_status_ == server_status)
     return;
   server_status_ = server_status;
   NotifyStatusChanged();
 }
@@ skipping 31 matching lines @@
     params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
     return false;
   }
 
   // Note that |post| may be aborted by now, which will just cause Init to fail
   // with CONNECTION_UNAVAILABLE.
   bool ok = post.get()->Init(
       path.c_str(), auth_token, params->buffer_in, &params->response);
 
   if (params->response.server_status == HttpResponse::SYNC_AUTH_ERROR) {
-    if (!auth_token_time_.is_null()) {
-      base::TimeDelta age = base::Time::Now() - auth_token_time_;
-      if (age < base::TimeDelta::FromHours(1)) {
-        UMA_HISTOGRAM_CUSTOM_TIMES("Sync.AuthServerRejectedTokenAgeShort",
-                                   age,
-                                   base::TimeDelta::FromSeconds(1),
-                                   base::TimeDelta::FromHours(1),
-                                   50);
-      }
-      UMA_HISTOGRAM_COUNTS("Sync.AuthServerRejectedTokenAgeLong",
-                           age.InDays());
-    }
     InvalidateAndClearAuthToken();
   }
 
   if (!ok || net::HTTP_OK != params->response.response_code)
     return false;
 
   if (post.get()->ReadBufferResponse(
       &params->buffer_out, &params->response, true)) {
     params->response.server_status = HttpResponse::SERVER_CONNECTION_OK;
     return true;
@@ skipping 58 matching lines @@
 
 std::ostream& operator << (std::ostream& s, const struct HttpResponse& hr) {
   s << " Response Code (bogus on error): " << hr.response_code;
   s << " Content-Length (bogus on error): " << hr.content_length;
   s << " Server Status: "
     << HttpResponse::GetServerConnectionCodeString(hr.server_status);
   return s;
 }
 
 }  // namespace syncer