Avoid useless SYNC_CYCLE_CONTINUATION sync cycle

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 61 matching lines @@
     }
 
     if (response.profiling_data().has_total_request_time()) {
       response_trace << " total time: "
                      << response.profiling_data().total_request_time() << "ms";
     }
     DVLOG(1) << response_trace.str();
   }
 }
 
+SyncerError ServerConnectionErrorAsSyncerError(
+    const HttpResponse::ServerConnectionCode server_status) {
+  switch (server_status) {
+    case HttpResponse::CONNECTION_UNAVAILABLE:
+      return NETWORK_CONNECTION_UNAVAILABLE;
+    case HttpResponse::IO_ERROR:
+      return NETWORK_IO_ERROR;
+    case HttpResponse::SYNC_SERVER_ERROR:
+      // FIXME what does this mean?
+      return SYNC_SERVER_ERROR;
+    case HttpResponse::SYNC_AUTH_ERROR:
+      return SYNC_AUTH_ERROR;
+    case HttpResponse::RETRY:
+      return SERVER_RETURN_TRANSIENT_ERROR;
+    case HttpResponse::SERVER_CONNECTION_OK:
+    case HttpResponse::NONE:
+    default:
+      NOTREACHED();
+      return UNINITIALIZED;
+  }
+}
+
+
+
 }  // namespace
 
 // static
 void SyncerProtoUtil::HandleMigrationDoneResponse(
   const sync_pb::ClientToServerResponse* response,
   sessions::SyncSession* session) {
   LOG_IF(ERROR, 0 >= response->migrated_data_type_id_size())
       << "MIGRATION_DONE but no types specified.";
   syncable::ModelTypeSet to_migrate;
   for (int i = 0; i < response->migrated_data_type_id_size(); i++) {
@@ skipping 203 matching lines @@
   if (error_type == ClientToServerResponse::CLEAR_PENDING ||
       error_type == ClientToServerResponse::NOT_MY_BIRTHDAY) {
       error.action = browser_sync::DISABLE_SYNC_ON_CLIENT;
   }  // There is no other action we can compute for legacy server.
   return error;
 }
 
 }  // namespace
 
 // static
-bool SyncerProtoUtil::PostClientToServerMessage(
+SyncerError 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;
+    return DIRECTORY_LOOKUP_FAILED;
 
   if (!PostAndProcessHeaders(session->context()->connection_manager(), session,
-                             msg, response))
-    return false;
+                             msg, response)) {
+    // There was an error establishing communication with the server.
+    // We can not proceed beyond this point.
+    const browser_sync::HttpResponse::ServerConnectionCode server_status =
+        session->context()->connection_manager()->server_status();
+
+    DCHECK(server_status != browser_sync::HttpResponse::NONE);
+    DCHECK(server_status != browser_sync::HttpResponse::SERVER_CONNECTION_OK);
+
+    return ServerConnectionErrorAsSyncerError(server_status);
+  }
 
   browser_sync::SyncProtocolError sync_protocol_error;
 
   // Birthday mismatch overrides any error that is sent by the server.
   if (!VerifyResponseBirthday(dir, response)) {
     sync_protocol_error.error_type = browser_sync::NOT_MY_BIRTHDAY;
      sync_protocol_error.action =
          browser_sync::DISABLE_SYNC_ON_CLIENT;
   } else if (response->has_error()) {
     // This is a new server. Just get the error from the protocol.
@@ skipping 10 matching lines @@
 
   // Inform the delegate of the error we got.
   session->delegate()->OnSyncProtocolError(session->TakeSnapshot());
 
   // Now do any special handling for the error type and decide on the return
   // value.
   switch (sync_protocol_error.error_type) {
     case browser_sync::UNKNOWN_ERROR:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
-      return false;
+      return SERVER_RETURN_UNKNOWN_ERROR;
     case browser_sync::SYNC_SUCCESS:
       LogResponseProfilingData(*response);
-      return true;
+      return NO_ERROR;
     case browser_sync::THROTTLED:
       LOG(WARNING) << "Client silenced by server.";
       HandleThrottleError(sync_protocol_error,
                           base::TimeTicks::Now() + GetThrottleDelay(*response),
                           session->context(),
                           session->delegate());
-      return false;
+      return SERVER_RETURN_THROTTLED;
     case browser_sync::TRANSIENT_ERROR:
-      return false;
+      return SERVER_RETURN_TRANSIENT_ERROR;
     case browser_sync::MIGRATION_DONE:
       HandleMigrationDoneResponse(response, session);
-      return false;
+      return SERVER_RETURN_MIGRATION_DONE;
     case browser_sync::CLEAR_PENDING:
+      return SERVER_RETURN_CLEAR_PENDING;
     case browser_sync::NOT_MY_BIRTHDAY:
-      return false;
+      return SERVER_RETURN_NOT_MY_BIRTHDAY;
     default:
       NOTREACHED();
-      return false;
+      return UNINITIALIZED;
   }
 }
 
 // static
 bool SyncerProtoUtil::Compare(const syncable::Entry& local_entry,
                               const SyncEntity& server_entry) {
   const std::string name = NameFromSyncEntity(server_entry);
 
   CHECK(local_entry.Get(ID) == server_entry.id()) <<
       " SyncerProtoUtil::Compare precondition not met.";
@@ skipping 113 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