sync/engine/apply_updates_and_resolve_conflicts_command.cc

// Copyright 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/engine/apply_updates_and_resolve_conflicts_command.h"

#include "base/location.h"
#include "sync/engine/conflict_resolver.h"
#include "sync/engine/update_applicator.h"
#include "sync/sessions/sync_session.h"
#include "sync/syncable/directory.h"
#include "sync/syncable/syncable_read_transaction.h"
#include "sync/syncable/syncable_write_transaction.h"

namespace syncer {

using sessions::SyncSession;

ApplyUpdatesAndResolveConflictsCommand::
    ApplyUpdatesAndResolveConflictsCommand() {}
ApplyUpdatesAndResolveConflictsCommand::
    ~ApplyUpdatesAndResolveConflictsCommand() {}

std::set<ModelSafeGroup>
ApplyUpdatesAndResolveConflictsCommand::GetGroupsToChange(
    const sessions::SyncSession& session) const {
  std::set<ModelSafeGroup> groups_with_unapplied_updates;

  FullModelTypeSet server_types_with_unapplied_updates;
  {
    syncable::Directory* dir = session.context()->directory();
    syncable::ReadTransaction trans(FROM_HERE, dir);
    server_types_with_unapplied_updates =
        dir->GetServerTypesWithUnappliedUpdates(&trans);
  }

  for (FullModelTypeSet::Iterator it =
           server_types_with_unapplied_updates.First(); it.Good(); it.Inc()) {
    groups_with_unapplied_updates.insert(
        GetGroupForModelType(it.Get(), session.context()->routing_info()));
  }

  return groups_with_unapplied_updates;
}

SyncerError ApplyUpdatesAndResolveConflictsCommand::ModelChangingExecuteImpl(
    SyncSession* session) {
  sessions::StatusController* status = session->mutable_status_controller();
  syncable::Directory* dir = session->context()->directory();
  syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir);

  // Compute server types with unapplied updates that fall under our
  // group restriction.
  const FullModelTypeSet server_types_with_unapplied_updates =
      dir->GetServerTypesWithUnappliedUpdates(&trans);
  FullModelTypeSet server_type_restriction;
  for (FullModelTypeSet::Iterator it =
           server_types_with_unapplied_updates.First(); it.Good(); it.Inc()) {
    if (GetGroupForModelType(it.Get(), session->context()->routing_info()) ==
        status->group_restriction()) {
      server_type_restriction.Put(it.Get());
    }
  }

  // Don't process control type updates here.  They will be handled elsewhere.
  FullModelTypeSet control_types = ToFullModelTypeSet(ControlTypes());
  server_type_restriction.RemoveAll(control_types);

  std::vector<int64> handles;
  dir->GetUnappliedUpdateMetaHandles(
      &trans, server_type_restriction, &handles);

  // First set of update application passes.
  UpdateApplicator applicator(
      dir->GetCryptographer(&trans),
      session->context()->routing_info(),
      status->group_restriction());
  applicator.AttemptApplications(&trans, handles);
  status->increment_num_updates_applied_by(applicator.updates_applied());
  status->increment_num_hierarchy_conflicts_by(
      applicator.hierarchy_conflicts());
  status->increment_num_encryption_conflicts_by(
      applicator.encryption_conflicts());

  if (applicator.simple_conflict_ids().size() != 0) {
    // Resolve the simple conflicts we just detected.
    ConflictResolver resolver;
    resolver.ResolveConflicts(&trans,
                              dir->GetCryptographer(&trans),
                              applicator.simple_conflict_ids(),
                              status);

    // Conflict resolution sometimes results in more updates to apply.
    handles.clear();
    dir->GetUnappliedUpdateMetaHandles(
        &trans, server_type_restriction, &handles);

    UpdateApplicator conflict_applicator(
        dir->GetCryptographer(&trans),
        session->context()->routing_info(),
        status->group_restriction());
    conflict_applicator.AttemptApplications(&trans, handles);

    // We count the number of updates from both applicator passes.
    status->increment_num_updates_applied_by(
        conflict_applicator.updates_applied());

    // Encryption conflicts should remain unchanged by the resolution of simple
    // conflicts.  Those can only be solved by updating our nigori key bag.
    DCHECK_EQ(conflict_applicator.encryption_conflicts(),
              applicator.encryption_conflicts());

    // Hierarchy conflicts should also remain unchanged, for reasons that are
    // more subtle.  Hierarchy conflicts exist when the application of a pending
    // update from the server would make the local folder hierarchy
    // inconsistent.  The resolution of simple conflicts could never affect the
    // hierarchy conflicting item directly, because hierarchy conflicts are not
    // processed by the conflict resolver.  It could, in theory, modify the
    // local hierarchy on which hierarchy conflict detection depends.  However,
    // the conflict resolution algorithm currently in use does not allow this.
    DCHECK_EQ(conflict_applicator.hierarchy_conflicts(),
              applicator.hierarchy_conflicts());

    // There should be no simple conflicts remaining.  We know this because the
    // resolver should have resolved all the conflicts we detected last time
    // and, by the two previous assertions, that no conflicts have been
    // downgraded from encryption or hierarchy down to simple.
    DCHECK(conflict_applicator.simple_conflict_ids().empty());
  }

  return SYNCER_OK;
}

}  // namespace syncer