New authorization framework for sync. ...

chrome/browser/sync/engine/syncer_proto_util.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/sync/engine/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/string_util.h"
-#include "chrome/browser/sync/engine/auth_watcher.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
+#include "chrome/browser/sync/engine/syncer_types.h"
 #include "chrome/browser/sync/engine/syncer_util.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 
 using std::string;
 using std::stringstream;
 using syncable::BASE_VERSION;
@@ skipping 95 matching lines @@
 // static
 void SyncerProtoUtil::AddRequestBirthday(syncable::Directory* dir,
                                          ClientToServerMessage* msg) {
   if (!dir->store_birthday().empty()) {
     msg->set_store_birthday(dir->store_birthday());
   }
 }
 
 // static
 bool SyncerProtoUtil::PostAndProcessHeaders(ServerConnectionManager* scm,
-                                            AuthWatcher* auth_watcher,
+                                            sessions::SyncSession* session,
                                             const ClientToServerMessage& msg,
                                             ClientToServerResponse* response) {
 
   std::string tx, rx;
   msg.SerializeToString(&tx);
 
   HttpResponse http_response;
   ServerConnectionManager::PostBufferParams params = {
     tx, &rx, &http_response
   };
 
   ScopedServerStatusWatcher server_status_watcher(scm, &http_response);
   if (!scm->PostBufferWithCachedAuth(&params, &server_status_watcher)) {
     LOG(WARNING) << "Error posting from syncer:" << http_response;
     return false;
   } else {
     std::string new_token =
         http_response.update_client_auth_header;
     if (!new_token.empty()) {
-      // We could also do this in the SCM's PostBufferWithAuth.
-      // But then we could be in the middle of authentication, which seems
-      // like a bad time to update the token. A consequence of this is that
-      // we can't reset the cookie in response to auth attempts, but this
-      // should be OK.
-      auth_watcher->RenewAuthToken(new_token);
+      SyncerEvent event(SyncerEvent::UPDATED_TOKEN);
+      event.updated_token = new_token;
+      session->context()->syncer_event_channel()->Notify(event);
     }
 
     if (response->ParseFromString(rx)) {
       // TODO(tim): This is an egregious layering violation (bug 35060).
       switch (response->error_code()) {
         case ClientToServerResponse::ACCESS_DENIED:
         case ClientToServerResponse::AUTH_INVALID:
         case ClientToServerResponse::USER_NOT_ACTIVATED:
           // Fires on ScopedServerStatusWatcher
           http_response.server_status = HttpResponse::SYNC_AUTH_ERROR;
@@ skipping 19 matching lines @@
                                       msg.get_updates().from_timestamp() == 0))
       << "Must call AddRequestBirthday to set birthday.";
 
   ScopedDirLookup dir(session->context()->directory_manager(),
       session->context()->account_name());
   if (!dir.good()) {
     return false;
   }
 
   if (!PostAndProcessHeaders(session->context()->connection_manager(),
-                             session->context()->auth_watcher(),
+                             session,
                              msg,
                              response)) {
     return false;
   }
 
   if (!VerifyResponseBirthday(dir, response)) {
     session->status_controller()->set_syncer_stuck(true);
     session->delegate()->OnShouldStopSyncingPermanently();
     return false;
   }
@@ skipping 144 matching lines @@
     const sync_pb::ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates()) {
     output.append(GetUpdatesResponseString(response.get_updates()));
   }
   return output;
 }
 
 }  // namespace browser_sync