Server directed error handling backend code.

chrome/browser/sync/engine/syncer_proto_util.cc

 // 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.
 
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/syncer.h"
@@ skipping 82 matching lines @@
   }
   session->status_controller()->set_types_needing_local_migration(to_migrate);
 }
 
 // static
 bool SyncerProtoUtil::VerifyResponseBirthday(syncable::Directory* dir,
     const ClientToServerResponse* response) {
 
   std::string local_birthday = dir->store_birthday();
 
+  // TODO(lipalani) : Remove this check here. When the new implementation
+  // becomes the default this check should go away. This is handled by the
+  // switch case in the new implementation.
   if (response->error_code() == ClientToServerResponse::CLEAR_PENDING ||
       response->error_code() == ClientToServerResponse::NOT_MY_BIRTHDAY) {
     // Birthday verification failures result in stopping sync and deleting
     // local sync data.
     return false;
   }
 
   if (local_birthday.empty()) {
     if (!response->has_store_birthday()) {
       LOG(WARNING) << "Expected a birthday on first sync.";
@@ skipping 91 matching lines @@
   if (!message.has_get_updates())
     return false;
   DCHECK_LT(0, message.get_updates().from_progress_marker_size());
   for (int i = 0; i < message.get_updates().from_progress_marker_size(); ++i) {
     if (!message.get_updates().from_progress_marker(i).token().empty())
       return false;
   }
   return true;
 }
 
+browser_sync::sessions::SyncErrorType ConvertSyncErrorTypePBToLocalType(
+    const sync_pb::ClientToServerResponse::ErrorType& error_type) {
+  switch (error_type) {
+    case ClientToServerResponse::SUCCESS:
+      return browser_sync::sessions::SUCCESS;
+    case ClientToServerResponse::NOT_MY_BIRTHDAY:
+      return browser_sync::sessions::NOT_MY_BIRTHDAY;
+    case ClientToServerResponse::THROTTLED:
+      return browser_sync::sessions::THROTTLED;
+    case ClientToServerResponse::CLEAR_PENDING:
+      return browser_sync::sessions::CLEAR_PENDING;
+    case ClientToServerResponse::TRANSIENT_ERROR:
+      return browser_sync::sessions::TRANSIENT_ERROR;
+    case ClientToServerResponse::MIGRATION_DONE:
+      return browser_sync::sessions::MIGRATION_DONE;
+    case ClientToServerResponse::UNKNOWN:
+      return browser_sync::sessions::UNKNOWN_ERROR;
+    case ClientToServerResponse::USER_NOT_ACTIVATED:
+    case ClientToServerResponse::AUTH_INVALID:
+    case ClientToServerResponse::ACCESS_DENIED:
+      return browser_sync::sessions::INVALID_CREDENTIAL;
+    default:
+      NOTREACHED();
+      return browser_sync::sessions::UNKNOWN_ERROR;
+  }
+}
+
+browser_sync::sessions::ClientAction ConvertClientActionPBToLocalClientAction(
+    const sync_pb::ClientToServerResponse::Error::Action& action) {
+  switch (action) {
+    case ClientToServerResponse::Error::UPGRADE_CLIENT:
+      return browser_sync::sessions::UPGRADE_CLIENT;
+    case ClientToServerResponse::Error::CLEAR_USER_DATA_AND_RESYNC:
+      return browser_sync::sessions::CLEAR_USER_DATA_AND_RESYNC;
+    case ClientToServerResponse::Error::ENABLE_SYNC_ON_ACCOUNT:
+      return browser_sync::sessions::ENABLE_SYNC_ON_ACCOUNT;
+    case ClientToServerResponse::Error::STOP_AND_RESTART_SYNC:
+      return browser_sync::sessions::STOP_AND_RESTART_SYNC;
+    case ClientToServerResponse::Error::DISABLE_SYNC_ON_CLIENT:
+      return browser_sync::sessions::DISABLE_SYNC_ON_CLIENT;
+    case ClientToServerResponse::Error::UNKNOWN_ACTION:
+      return browser_sync::sessions::UNKNOWN_ACTION;
+    default:
+      NOTREACHED();
+      return browser_sync::sessions::UNKNOWN_ACTION;
+  }
+}
+
+browser_sync::sessions::SyncError ConvertErrorPBToLocalType(
+    const sync_pb::ClientToServerResponse::Error& error) {
+  browser_sync::sessions::SyncError sync_error;
+  sync_error.error_type = ConvertSyncErrorTypePBToLocalType(error.error_type());
+  sync_error.error_description = error.error_description();
+  sync_error.url = error.url();
+  sync_error.action = ConvertClientActionPBToLocalClientAction(error.action());
+
+  return sync_error;
+}
+
 }  // namespace
 
 // static
 bool SyncerProtoUtil::PostClientToServerMessage(
     const ClientToServerMessage& msg,
     ClientToServerResponse* response,
     SyncSession* session) {
 
   CHECK(response);
   DCHECK(!msg.get_updates().has_from_timestamp());  // Deprecated.
   DCHECK(!msg.get_updates().has_requested_types());  // Deprecated.
   DCHECK(msg.has_store_birthday() || IsVeryFirstGetUpdates(msg))
       << "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,
                              msg, response))
     return false;
 
+  if (response->has_error()) {
+    // We are talking to a server that is capable of sending the |error| tag.
+    browser_sync::sessions::SyncError sync_error = ConvertErrorPBToLocalType(
+        response->error());
+
+    // Birthday mismatch overrides any error that is sent by the server.
+    if (!VerifyResponseBirthday(dir, response)) {
+       sync_error.error_type = browser_sync::sessions::NOT_MY_BIRTHDAY;
+       sync_error.action = browser_sync::sessions::DISABLE_SYNC_ON_CLIENT;
+    }
+
+    // Now set the error into the status so the layers above us could read it.
+    sessions::StatusController* status = session->status_controller();
+    status->set_sync_error(sync_error);
+
+    // Inform the delegate of the error we got.
+    session->delegate()->OnSyncError(session);
+
+    // Now do any special handling for the error type and decide on the return
+    // value.
+    switch (sync_error.error_type) {
+      case browser_sync::sessions::UNKNOWN_ERROR:
+        LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
+                     << "recent version.";
+        return false;
+      case browser_sync::sessions::SUCCESS:
+        LogResponseProfilingData(*response);
+        return true;
+      case browser_sync::sessions::THROTTLED:
+        LOG(WARNING) << "Client silenced by server.";
+        session->delegate()->OnSilencedUntil(base::TimeTicks::Now() +
+            GetThrottleDelay(*response));
+        return false;
+      case browser_sync::sessions::TRANSIENT_ERROR:
+        return false;
+      case browser_sync::sessions::MIGRATION_DONE:
+        HandleMigrationDoneResponse(response, session);
+        return false;
+      default:
+        NOTREACHED();
+        return false;
+    }
+  }
+
+  // TODO(lipalani): Plug this legacy implementation to the new error framework.
+  // New implementation code would have returned before by now. This is waiting
+  // on the frontend code being implemented. Otherwise ripping this would break
+  // sync.
   if (!VerifyResponseBirthday(dir, response)) {
     session->status_controller()->set_syncer_stuck(true);
     session->delegate()->OnShouldStopSyncingPermanently();
     return false;
   }
 
   switch (response->error_code()) {
     case ClientToServerResponse::UNKNOWN:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
@@ skipping 143 matching lines @@
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     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