Dont retry sync in case of auth errors.

chrome/browser/sync/engine/net/server_connection_manager.h

 // Copyright (c) 2011 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 259 matching lines @@
 
   // Factory method to create a Post object we can use for communication with
   // the server.
   virtual Post* MakePost();
 
   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) {
+  // Returns true if the auth token is succesfully set and false otherwise.
+  bool set_auth_token(const std::string& auth_token) {
     // TODO(chron): Consider adding a message loop check here.
     base::AutoLock lock(auth_token_mutex_);
-    auth_token_.assign(auth_token);
+    if (previous_invalid_token_ != auth_token) {
+      auth_token_.assign(auth_token);
+      previous_invalid_token_ = std::string();
+      return true;
+    }
+    return false;
+  }
+
+  void reset_auth_token() {

[tim (not reviewing), 2011/08/04 00:24:40]

lets call this InvalidateAndClearAuthToken()  (or just InvalidateAuthToken()).

reset sounds more innocent than it is here, since we imply "invalidation" (esp
in unix_hacker_style which implies a simple, basic clear).

[lipalani1, 2011/08/04 01:14:33]

Done.

+    // Copy over the token to previous invalid token.
+    base::AutoLock lock(auth_token_mutex_);
+    if (!auth_token_.empty()) {
+      previous_invalid_token_.assign(auth_token_);

[tim (not reviewing), 2011/08/04 00:24:40]

With the method change above, lets tweak this slightly to be
previously_invalidated_token_

[lipalani1, 2011/08/04 01:14:33]

Done.

+      auth_token_ = std::string();
+    }
   }
 
   const std::string auth_token() const {
     base::AutoLock lock(auth_token_mutex_);
     return auth_token_;
   }
 
  protected:
   inline std::string proto_sync_path() const {
     base::AutoLock lock(path_mutex_);
@@ skipping 37 matching lines @@
 
   // The paths we post to.
   mutable base::Lock path_mutex_;
   std::string proto_sync_path_;
   std::string get_time_path_;
 
   mutable base::Lock auth_token_mutex_;
   // The auth token to use in authenticated requests. Set by the AuthWatcher.
   std::string auth_token_;
 
+  // The previous auth token that is invalid now.

[tim (not reviewing), 2011/08/04 00:24:40]

rename the var as suggested, and comment could be "The last token to have been
invalidated."

[lipalani1, 2011/08/04 01:14:33]

Done.

+  std::string previous_invalid_token_;
+
   base::Lock error_count_mutex_;  // Protects error_count_
   int error_count_;  // Tracks the number of connection errors.
 
   scoped_refptr<ObserverListThreadSafe<ServerConnectionEventListener> >
      listeners_;
 
   // Volatile so various threads can call server_status() without
   // synchronization.
   volatile HttpResponse::ServerConnectionCode server_status_;
   bool server_reachable_;
@@ skipping 17 matching lines @@
 // settings.
 bool FillMessageWithShareDetails(sync_pb::ClientToServerMessage* csm,
                                  syncable::DirectoryManager* manager,
                                  const std::string& share);
 
 std::ostream& operator<<(std::ostream& s, const struct HttpResponse& hr);
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_NET_SERVER_CONNECTION_MANAGER_H_