[Sync] Fix sync scheduler/session logic determining successful commands.

sync/sessions/sync_session.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/sessions/sync_session.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 41 matching lines @@
 SyncSession::SyncSession(SyncSessionContext* context, Delegate* delegate,
     const SyncSourceInfo& source,
     const ModelSafeRoutingInfo& routing_info,
     const std::vector<ModelSafeWorker*>& workers)
     : context_(context),
       source_(source),
       write_transaction_(NULL),
       delegate_(delegate),
       workers_(workers),
       routing_info_(routing_info),
-      enabled_groups_(ComputeEnabledGroups(routing_info_, workers_)) {
+      enabled_groups_(ComputeEnabledGroups(routing_info_, workers_)),
+      finished_(false) {
   status_controller_.reset(new StatusController(routing_info_));
   std::sort(workers_.begin(), workers_.end());
 }
 
 SyncSession::~SyncSession() {}
 
 void SyncSession::Coalesce(const SyncSession& session) {
   if (context_ != session.context() || delegate_ != session.delegate_) {
     NOTREACHED();
     return;
@@ skipping 146 matching lines @@
   }
 
   return enabled_groups_with_verified_updates;
 }
 
 namespace {
 // Return true if the command in question was attempted and did not complete
 // successfully.
 //
 bool IsError(SyncerError error) {
-  return error != UNSET
-      && error != SYNCER_OK;
+  return error != UNSET && error != SYNCER_OK;
+}
+
+// Returns false iff one of the command results had an error.
+bool HadErrors(const ErrorCounters& error) {
+  const bool download_updates_error =
+      IsError(error.last_download_updates_result);
+  const bool post_commit_error = IsError(error.last_post_commit_result);
+  const bool process_commit_response_error =
+      IsError(error.last_process_commit_response_result);
+  return download_updates_error ||
+         post_commit_error ||
+         process_commit_response_error;
 }
 }  // namespace
 
 bool SyncSession::Succeeded() const {
-  const bool download_updates_error =
-      IsError(status_controller_->error().last_download_updates_result);
-  const bool post_commit_error =
-      IsError(status_controller_->error().last_post_commit_result);
-  const bool process_commit_response_error =
-      IsError(status_controller_->error().last_process_commit_response_result);
-  return !download_updates_error
-      && !post_commit_error
-      && !process_commit_response_error;
+  const ErrorCounters& error = status_controller_->error();
+  return finished_ && !HadErrors(error);
+}
+
+bool SyncSession::SuccessfullyReachServer() const {
+  const ErrorCounters& error = status_controller_->error();
+  bool reach_server = false;
+  if (error.last_download_updates_result == SYNCER_OK ||
+      error.last_post_commit_result == SYNCER_OK ||
+      error.last_process_commit_response_result == SYNCER_OK)
+    reach_server = true;
+  return reach_server && !HadErrors(error);
+}
+
+void SyncSession::SetFinished() {
+  finished_ = true;
 }
 
 }  // namespace sessions
 }  // namespace browser_sync