// 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_util.h"
#include <algorithm>
#include <set>
#include <string>
#include <vector>
#include "chrome/browser/sync/engine/conflict_resolver.h"
#include "chrome/browser/sync/engine/syncer_proto_util.h"
#include "chrome/browser/sync/engine/syncer_types.h"
#include "chrome/browser/sync/engine/syncproto.h"
#include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
#include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
#include "chrome/browser/sync/protocol/sync.pb.h"
#include "chrome/browser/sync/syncable/directory_manager.h"
#include "chrome/browser/sync/syncable/model_type.h"
#include "chrome/browser/sync/syncable/nigori_util.h"
#include "chrome/browser/sync/syncable/syncable.h"
#include "chrome/browser/sync/syncable/syncable_changes_version.h"
using syncable::BASE_VERSION;
using syncable::Blob;
using syncable::CHANGES_VERSION;
using syncable::CREATE;
using syncable::CREATE_NEW_UPDATE_ITEM;
using syncable::CTIME;
using syncable::Directory;
using syncable::Entry;
using syncable::GET_BY_HANDLE;
using syncable::GET_BY_ID;
using syncable::ID;
using syncable::IS_DEL;
using syncable::IS_DIR;
using syncable::IS_UNAPPLIED_UPDATE;
using syncable::IS_UNSYNCED;
using syncable::Id;
using syncable::META_HANDLE;
using syncable::MTIME;
using syncable::MutableEntry;
using syncable::NEXT_ID;
using syncable::NON_UNIQUE_NAME;
using syncable::PARENT_ID;
using syncable::PREV_ID;
using syncable::ReadTransaction;
using syncable::SERVER_CTIME;
using syncable::SERVER_IS_DEL;
using syncable::SERVER_IS_DIR;
using syncable::SERVER_MTIME;
using syncable::SERVER_NON_UNIQUE_NAME;
using syncable::SERVER_PARENT_ID;
using syncable::SERVER_POSITION_IN_PARENT;
using syncable::SERVER_SPECIFICS;
using syncable::SERVER_VERSION;
using syncable::UNIQUE_CLIENT_TAG;
using syncable::UNIQUE_SERVER_TAG;
using syncable::SPECIFICS;
using syncable::SYNCER;
using syncable::WriteTransaction;
namespace browser_sync {
// Returns the number of unsynced entries.
// static
int SyncerUtil::GetUnsyncedEntries(syncable::BaseTransaction* trans,
std::vector<int64> *handles) {
trans->directory()->GetUnsyncedMetaHandles(trans, handles);
VLOG_IF(1, !handles->empty()) << "Have " << handles->size()
<< " unsynced items.";
return handles->size();
}
// static
void SyncerUtil::ChangeEntryIDAndUpdateChildren(
syncable::WriteTransaction* trans,
syncable::MutableEntry* entry,
const syncable::Id& new_id,
syncable::Directory::ChildHandles* children) {
syncable::Id old_id = entry->Get(ID);
if (!entry->Put(ID, new_id)) {
Entry old_entry(trans, GET_BY_ID, new_id);
CHECK(old_entry.good());
LOG(FATAL) << "Attempt to change ID to " << new_id
<< " conflicts with existing entry.\n\n"
<< *entry << "\n\n" << old_entry;
}
if (entry->Get(IS_DIR)) {
// Get all child entries of the old id.
trans->directory()->GetChildHandles(trans, old_id, children);
Directory::ChildHandles::iterator i = children->begin();
while (i != children->end()) {
MutableEntry child_entry(trans, GET_BY_HANDLE, *i++);
CHECK(child_entry.good());
// Use the unchecked setter here to avoid touching the child's NEXT_ID
// and PREV_ID fields (which Put(PARENT_ID) would normally do to
// maintain linked-list invariants). In this case, NEXT_ID and PREV_ID
// among the children will be valid after the loop, since we update all
// the children at once.
child_entry.PutParentIdPropertyOnly(new_id);
}
}
// Update Id references on the previous and next nodes in the sibling
// order. Do this by reinserting into the linked list; the first
// step in PutPredecessor is to Unlink from the existing order, which
// will overwrite the stale Id value from the adjacent nodes.
if (entry->Get(PREV_ID) == entry->Get(NEXT_ID) &&
entry->Get(PREV_ID) == old_id) {
// We just need a shallow update to |entry|'s fields since it is already
// self looped.
entry->Put(NEXT_ID, new_id);
entry->Put(PREV_ID, new_id);
} else {
entry->PutPredecessor(entry->Get(PREV_ID));
}
}
// static
void SyncerUtil::ChangeEntryIDAndUpdateChildren(
syncable::WriteTransaction* trans,
syncable::MutableEntry* entry,
const syncable::Id& new_id) {
syncable::Directory::ChildHandles children;
ChangeEntryIDAndUpdateChildren(trans, entry, new_id, &children);
}
// static
syncable::Id SyncerUtil::FindLocalIdToUpdate(
syncable::BaseTransaction* trans,
const SyncEntity& update) {
// Expected entry points of this function:
// SyncEntity has NOT been applied to SERVER fields.
// SyncEntity has NOT been applied to LOCAL fields.
// DB has not yet been modified, no entries created for this update.
const std::string& client_id = trans->directory()->cache_guid();
if (update.has_client_defined_unique_tag() &&
!update.client_defined_unique_tag().empty()) {
// When a server sends down a client tag, the following cases can occur:
// 1) Client has entry for tag already, ID is server style, matches
// 2) Client has entry for tag already, ID is server, doesn't match.
// 3) Client has entry for tag already, ID is local, (never matches)
// 4) Client has no entry for tag
// Case 1, we don't have to do anything since the update will
// work just fine. Update will end up in the proper entry, via ID lookup.
// Case 2 - Happens very rarely due to lax enforcement of client tags
// on the server, if two clients commit the same tag at the same time.
// When this happens, we pick the lexically-least ID and ignore all other
// items.
// Case 3 - We need to replace the local ID with the server ID so that
// this update gets targeted at the correct local entry; we expect conflict
// resolution to occur.
// Case 4 - Perfect. Same as case 1.
syncable::Entry local_entry(trans, syncable::GET_BY_CLIENT_TAG,
update.client_defined_unique_tag());
// The SyncAPI equivalent of this function will return !good if IS_DEL.
// The syncable version will return good even if IS_DEL.
// TODO(chron): Unit test the case with IS_DEL and make sure.
if (local_entry.good()) {
if (local_entry.Get(ID).ServerKnows()) {
if (local_entry.Get(ID) != update.id()) {
// Case 2.
LOG(WARNING) << "Duplicated client tag.";
if (local_entry.Get(ID) < update.id()) {
// Signal an error; drop this update on the floor. Note that
// we don't server delete the item, because we don't allow it to
// exist locally at all. So the item will remain orphaned on
// the server, and we won't pay attention to it.
return syncable::kNullId;
}
}
// Target this change to the existing local entry; later,
// we'll change the ID of the local entry to update.id()
// if needed.
return local_entry.Get(ID);
} else {
// Case 3: We have a local entry with the same client tag.
// We should change the ID of the local entry to the server entry.
// This will result in an server ID with base version == 0, but that's
// a legal state for an item with a client tag. By changing the ID,
// update will now be applied to local_entry.
DCHECK(0 == local_entry.Get(BASE_VERSION) ||
CHANGES_VERSION == local_entry.Get(BASE_VERSION));
return local_entry.Get(ID);
}
}
} else if (update.has_originator_cache_guid() &&
update.originator_cache_guid() == client_id) {
// If a commit succeeds, but the response does not come back fast enough
// then the syncer might assume that it was never committed.
// The server will track the client that sent up the original commit and
// return this in a get updates response. When this matches a local
// uncommitted item, we must mutate our local item and version to pick up
// the committed version of the same item whose commit response was lost.
// There is however still a race condition if the server has not
// completed the commit by the time the syncer tries to get updates
// again. To mitigate this, we need to have the server time out in
// a reasonable span, our commit batches have to be small enough
// to process within our HTTP response "assumed alive" time.
// We need to check if we have an entry that didn't get its server
// id updated correctly. The server sends down a client ID
// and a local (negative) id. If we have a entry by that
// description, we should update the ID and version to the
// server side ones to avoid multiple copies of the same thing.
syncable::Id client_item_id = syncable::Id::CreateFromClientString(
update.originator_client_item_id());
DCHECK(!client_item_id.ServerKnows());
syncable::Entry local_entry(trans, GET_BY_ID, client_item_id);
// If it exists, then our local client lost a commit response. Use
// the local entry.
if (local_entry.good() && !local_entry.Get(IS_DEL)) {
int64 old_version = local_entry.Get(BASE_VERSION);
int64 new_version = update.version();
DCHECK_LE(old_version, 0);
DCHECK_GT(new_version, 0);
// Otherwise setting the base version could cause a consistency failure.
// An entry should never be version 0 and SYNCED.
DCHECK(local_entry.Get(IS_UNSYNCED));
// Just a quick sanity check.
DCHECK(!local_entry.Get(ID).ServerKnows());
VLOG(1) << "Reuniting lost commit response IDs. server id: "
<< update.id() << " local id: " << local_entry.Get(ID)
<< " new version: " << new_version;
return local_entry.Get(ID);
}
}
// Fallback: target an entry having the server ID, creating one if needed.
return update.id();
}
// static
UpdateAttemptResponse SyncerUtil::AttemptToUpdateEntry(
syncable::WriteTransaction* const trans,
syncable::MutableEntry* const entry,
ConflictResolver* resolver,
Cryptographer* cryptographer) {
CHECK(entry->good());
if (!entry->Get(IS_UNAPPLIED_UPDATE))
return SUCCESS; // No work to do.
syncable::Id id = entry->Get(ID);
if (entry->Get(IS_UNSYNCED)) {
VLOG(1) << "Skipping update, returning conflict for: " << id
<< " ; it's unsynced.";
return CONFLICT;
}
if (!entry->Get(SERVER_IS_DEL)) {
syncable::Id new_parent = entry->Get(SERVER_PARENT_ID);
Entry parent(trans, GET_BY_ID, new_parent);
// A note on non-directory parents:
// We catch most unfixable tree invariant errors at update receipt time,
// however we deal with this case here because we may receive the child
// first then the illegal parent. Instead of dealing with it twice in
// different ways we deal with it once here to reduce the amount of code and
// potential errors.
if (!parent.good() || parent.Get(IS_DEL) || !parent.Get(IS_DIR)) {
return CONFLICT;
}
if (entry->Get(PARENT_ID) != new_parent) {
if (!entry->Get(IS_DEL) && !IsLegalNewParent(trans, id, new_parent)) {
VLOG(1) << "Not updating item " << id
<< ", illegal new parent (would cause loop).";
return CONFLICT;
}
}
} else if (entry->Get(IS_DIR)) {
Directory::ChildHandles handles;
trans->directory()->GetChildHandles(trans, id, &handles);
if (!handles.empty()) {
// If we have still-existing children, then we need to deal with
// them before we can process this change.
VLOG(1) << "Not deleting directory; it's not empty " << *entry;
return CONFLICT;
}
}
// We intercept updates to the Nigori node, update the Cryptographer and
// encrypt any unsynced changes here because there is no Nigori
// ChangeProcessor.
const sync_pb::EntitySpecifics& specifics = entry->Get(SERVER_SPECIFICS);
if (specifics.HasExtension(sync_pb::nigori)) {
const sync_pb::NigoriSpecifics& nigori =
specifics.GetExtension(sync_pb::nigori);
if (!nigori.encrypted().blob().empty()) {
if (cryptographer->CanDecrypt(nigori.encrypted())) {
cryptographer->SetKeys(nigori.encrypted());
} else {
cryptographer->SetPendingKeys(nigori.encrypted());
}
}
// Make sure any unsynced changes are properly encrypted as necessary.
syncable::ModelTypeSet encrypted_types =
syncable::GetEncryptedDataTypesFromNigori(nigori);
if (!VerifyUnsyncedChangesAreEncrypted(trans, encrypted_types) &&
(!cryptographer->is_ready() ||
!syncable::ProcessUnsyncedChangesForEncryption(trans, encrypted_types,
cryptographer))) {
// We were unable to encrypt the changes, possibly due to a missing
// passphrase. We return conflict, even though the conflict is with the
// unsynced change and not the nigori node. We ensure foward progress
// because the cryptographer already has the pending keys set, so once
// the new passphrase is entered we should be able to encrypt properly.
// And, because this update will not be applied yet, next time around
// we will properly encrypt all appropriate unsynced data.
VLOG(1) << "Marking nigori node update as conflicting due to being unable"
<< " to encrypt all necessary unsynced changes.";
return CONFLICT;
}
// Note that we don't bother to encrypt any synced data that now requires
// encryption. The machine that turned on encryption should encrypt
// everything itself. It's possible it could get interrupted during this
// process, but we currently reencrypt everything at startup as well,
// so as soon as a client is restarted with this datatype encrypted, all the
// data should be updated as necessary.
}
// Only apply updates that we can decrypt. Updates that can't be decrypted yet
// will stay in conflict until the user provides a passphrase that lets the
// Cryptographer decrypt them.
if (!entry->Get(SERVER_IS_DIR)) {
if (specifics.has_encrypted() &&
!cryptographer->CanDecrypt(specifics.encrypted())) {
// We can't decrypt this node yet.
return CONFLICT;
} else if (specifics.HasExtension(sync_pb::password)) {
// Passwords use their own legacy encryption scheme.
const sync_pb::PasswordSpecifics& password =
specifics.GetExtension(sync_pb::password);
if (!cryptographer->CanDecrypt(password.encrypted())) {
return CONFLICT;
}
}
}
SyncerUtil::UpdateLocalDataFromServerData(trans, entry);
return SUCCESS;
}
namespace {
// Helper to synthesize a new-style sync_pb::EntitySpecifics for use locally,
// when the server speaks only the old sync_pb::SyncEntity_BookmarkData-based
// protocol.
void UpdateBookmarkSpecifics(const std::string& singleton_tag,
const std::string& url,
const std::string& favicon_bytes,
MutableEntry* local_entry) {
// In the new-style protocol, the server no longer sends bookmark info for
// the "google_chrome" folder. Mimic that here.
if (singleton_tag == "google_chrome")
return;
sync_pb::EntitySpecifics pb;
sync_pb::BookmarkSpecifics* bookmark = pb.MutableExtension(sync_pb::bookmark);
if (!url.empty())
bookmark->set_url(url);
if (!favicon_bytes.empty())
bookmark->set_favicon(favicon_bytes);
local_entry->Put(SERVER_SPECIFICS, pb);
}
} // namespace
// Pass in name and checksum because of UTF8 conversion.
// static
void SyncerUtil::UpdateServerFieldsFromUpdate(
MutableEntry* target,
const SyncEntity& update,
const std::string& name) {
if (update.deleted()) {
if (target->Get(SERVER_IS_DEL)) {
// If we already think the item is server-deleted, we're done.
// Skipping these cases prevents our committed deletions from coming
// back and overriding subsequent undeletions. For non-deleted items,
// the version number check has a similar effect.
return;
}
// The server returns very lightweight replies for deletions, so we don't
// clobber a bunch of fields on delete.
target->Put(SERVER_IS_DEL, true);
if (!target->Get(UNIQUE_CLIENT_TAG).empty()) {
// Items identified by the client unique tag are undeletable; when
// they're deleted, they go back to version 0.
target->Put(SERVER_VERSION, 0);
} else {
// Otherwise, fake a server version by bumping the local number.
target->Put(SERVER_VERSION,
std::max(target->Get(SERVER_VERSION),
target->Get(BASE_VERSION)) + 1);
}
target->Put(IS_UNAPPLIED_UPDATE, true);
return;
}
DCHECK(target->Get(ID) == update.id())
<< "ID Changing not supported here";
target->Put(SERVER_PARENT_ID, update.parent_id());
target->Put(SERVER_NON_UNIQUE_NAME, name);
target->Put(SERVER_VERSION, update.version());
target->Put(SERVER_CTIME,
ServerTimeToClientTime(update.ctime()));
target->Put(SERVER_MTIME,
ServerTimeToClientTime(update.mtime()));
target->Put(SERVER_IS_DIR, update.IsFolder());
if (update.has_server_defined_unique_tag()) {
const std::string& tag = update.server_defined_unique_tag();
target->Put(UNIQUE_SERVER_TAG, tag);
}
if (update.has_client_defined_unique_tag()) {
const std::string& tag = update.client_defined_unique_tag();
target->Put(UNIQUE_CLIENT_TAG, tag);
}
// Store the datatype-specific part as a protobuf.
if (update.has_specifics()) {
DCHECK(update.GetModelType() != syncable::UNSPECIFIED)
<< "Storing unrecognized datatype in sync database.";
target->Put(SERVER_SPECIFICS, update.specifics());
} else if (update.has_bookmarkdata()) {
// Legacy protocol response for bookmark data.
const SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
UpdateBookmarkSpecifics(update.server_defined_unique_tag(),
bookmark.bookmark_url(),
bookmark.bookmark_favicon(),
target);
}
if (update.has_position_in_parent())
target->Put(SERVER_POSITION_IN_PARENT, update.position_in_parent());
target->Put(SERVER_IS_DEL, update.deleted());
// We only mark the entry as unapplied if its version is greater than the
// local data. If we're processing the update that corresponds to one of our
// commit we don't apply it as time differences may occur.
if (update.version() > target->Get(BASE_VERSION)) {
target->Put(IS_UNAPPLIED_UPDATE, true);
}
}
// Creates a new Entry iff no Entry exists with the given id.
// static
void SyncerUtil::CreateNewEntry(syncable::WriteTransaction *trans,
const syncable::Id& id) {
syncable::MutableEntry entry(trans, syncable::GET_BY_ID, id);
if (!entry.good()) {
syncable::MutableEntry new_entry(trans, syncable::CREATE_NEW_UPDATE_ITEM,
id);
}
}
// static
bool SyncerUtil::ServerAndLocalOrdersMatch(syncable::Entry* entry) {
// Find the closest up-to-date local sibling by walking the linked list.
syncable::Id local_up_to_date_predecessor = entry->Get(PREV_ID);
while (!local_up_to_date_predecessor.IsRoot()) {
Entry local_prev(entry->trans(), GET_BY_ID, local_up_to_date_predecessor);
if (!local_prev.good() || local_prev.Get(IS_DEL))
return false;
if (!local_prev.Get(IS_UNAPPLIED_UPDATE) && !local_prev.Get(IS_UNSYNCED))
break;
local_up_to_date_predecessor = local_prev.Get(PREV_ID);
}
// Now find the closest up-to-date sibling in the server order.
syncable::Id server_up_to_date_predecessor =
entry->ComputePrevIdFromServerPosition(entry->Get(SERVER_PARENT_ID));
return server_up_to_date_predecessor == local_up_to_date_predecessor;
}
// static
bool SyncerUtil::ServerAndLocalEntriesMatch(syncable::Entry* entry) {
if (!ClientAndServerTimeMatch(
entry->Get(CTIME), ClientTimeToServerTime(entry->Get(SERVER_CTIME)))) {
LOG(WARNING) << "Client and server time mismatch";
return false;
}
if (entry->Get(IS_DEL) && entry->Get(SERVER_IS_DEL))
return true;
// Name should exactly match here.
if (!(entry->Get(NON_UNIQUE_NAME) == entry->Get(SERVER_NON_UNIQUE_NAME))) {
LOG(WARNING) << "Unsanitized name mismatch";
return false;
}
if (entry->Get(PARENT_ID) != entry->Get(SERVER_PARENT_ID) ||
entry->Get(IS_DIR) != entry->Get(SERVER_IS_DIR) ||
entry->Get(IS_DEL) != entry->Get(SERVER_IS_DEL)) {
LOG(WARNING) << "Metabit mismatch";
return false;
}
if (!ServerAndLocalOrdersMatch(entry)) {
LOG(WARNING) << "Server/local ordering mismatch";
return false;
}
// TODO(ncarter): This is unfortunately heavyweight. Can we do better?
if (entry->Get(SPECIFICS).SerializeAsString() !=
entry->Get(SERVER_SPECIFICS).SerializeAsString()) {
LOG(WARNING) << "Specifics mismatch";
return false;
}
if (entry->Get(IS_DIR))
return true;
// For historical reasons, a folder's MTIME changes when its contents change.
// TODO(ncarter): Remove the special casing of MTIME.
bool time_match = ClientAndServerTimeMatch(entry->Get(MTIME),
ClientTimeToServerTime(entry->Get(SERVER_MTIME)));
if (!time_match) {
LOG(WARNING) << "Time mismatch";
}
return time_match;
}
// static
void SyncerUtil::SplitServerInformationIntoNewEntry(
syncable::WriteTransaction* trans,
syncable::MutableEntry* entry) {
syncable::Id id = entry->Get(ID);
ChangeEntryIDAndUpdateChildren(trans, entry, trans->directory()->NextId());
entry->Put(BASE_VERSION, 0);
MutableEntry new_entry(trans, CREATE_NEW_UPDATE_ITEM, id);
CopyServerFields(entry, &new_entry);
ClearServerData(entry);
VLOG(1) << "Splitting server information, local entry: " << *entry
<< " server entry: " << new_entry;
}
// This function is called on an entry when we can update the user-facing data
// from the server data.
// static
void SyncerUtil::UpdateLocalDataFromServerData(
syncable::WriteTransaction* trans,
syncable::MutableEntry* entry) {
DCHECK(!entry->Get(IS_UNSYNCED));
DCHECK(entry->Get(IS_UNAPPLIED_UPDATE));
VLOG(2) << "Updating entry : " << *entry;
// Start by setting the properties that determine the model_type.
entry->Put(SPECIFICS, entry->Get(SERVER_SPECIFICS));
entry->Put(IS_DIR, entry->Get(SERVER_IS_DIR));
// This strange dance around the IS_DEL flag avoids problems when setting
// the name.
// TODO(chron): Is this still an issue? Unit test this codepath.
if (entry->Get(SERVER_IS_DEL)) {
entry->Put(IS_DEL, true);
} else {
entry->Put(NON_UNIQUE_NAME, entry->Get(SERVER_NON_UNIQUE_NAME));
entry->Put(PARENT_ID, entry->Get(SERVER_PARENT_ID));
CHECK(entry->Put(IS_DEL, false));
Id new_predecessor =
entry->ComputePrevIdFromServerPosition(entry->Get(SERVER_PARENT_ID));
CHECK(entry->PutPredecessor(new_predecessor))
<< " Illegal predecessor after converting from server position.";
}
entry->Put(CTIME, entry->Get(SERVER_CTIME));
entry->Put(MTIME, entry->Get(SERVER_MTIME));
entry->Put(BASE_VERSION, entry->Get(SERVER_VERSION));
entry->Put(IS_DEL, entry->Get(SERVER_IS_DEL));
entry->Put(IS_UNAPPLIED_UPDATE, false);
}
// static
VerifyCommitResult SyncerUtil::ValidateCommitEntry(
syncable::Entry* entry) {
syncable::Id id = entry->Get(ID);
if (id == entry->Get(PARENT_ID)) {
CHECK(id.IsRoot()) << "Non-root item is self parenting." << *entry;
// If the root becomes unsynced it can cause us problems.
LOG(ERROR) << "Root item became unsynced " << *entry;
return VERIFY_UNSYNCABLE;
}
if (entry->IsRoot()) {
LOG(ERROR) << "Permanent item became unsynced " << *entry;
return VERIFY_UNSYNCABLE;
}
if (entry->Get(IS_DEL) && !entry->Get(ID).ServerKnows()) {
// Drop deleted uncommitted entries.
return VERIFY_UNSYNCABLE;
}
return VERIFY_OK;
}
// static
bool SyncerUtil::AddItemThenPredecessors(
syncable::BaseTransaction* trans,
syncable::Entry* item,
syncable::IndexedBitField inclusion_filter,
syncable::MetahandleSet* inserted_items,
std::vector<syncable::Id>* commit_ids) {
if (!inserted_items->insert(item->Get(META_HANDLE)).second)
return false;
commit_ids->push_back(item->Get(ID));
if (item->Get(IS_DEL))
return true; // Deleted items have no predecessors.
Id prev_id = item->Get(PREV_ID);
while (!prev_id.IsRoot()) {
Entry prev(trans, GET_BY_ID, prev_id);
CHECK(prev.good()) << "Bad id when walking predecessors.";
if (!prev.Get(inclusion_filter))
break;
if (!inserted_items->insert(prev.Get(META_HANDLE)).second)
break;
commit_ids->push_back(prev_id);
prev_id = prev.Get(PREV_ID);
}
return true;
}
// static
void SyncerUtil::AddPredecessorsThenItem(
syncable::BaseTransaction* trans,
syncable::Entry* item,
syncable::IndexedBitField inclusion_filter,
syncable::MetahandleSet* inserted_items,
std::vector<syncable::Id>* commit_ids) {
size_t initial_size = commit_ids->size();
if (!AddItemThenPredecessors(trans, item, inclusion_filter, inserted_items,
commit_ids))
return;
// Reverse what we added to get the correct order.
std::reverse(commit_ids->begin() + initial_size, commit_ids->end());
}
// static
void SyncerUtil::MarkDeletedChildrenSynced(
const syncable::ScopedDirLookup &dir,
std::set<syncable::Id>* deleted_folders) {
// There's two options here.
// 1. Scan deleted unsynced entries looking up their pre-delete tree for any
// of the deleted folders.
// 2. Take each folder and do a tree walk of all entries underneath it.
// #2 has a lower big O cost, but writing code to limit the time spent inside
// the transaction during each step is simpler with 1. Changing this decision
// may be sensible if this code shows up in profiling.
if (deleted_folders->empty())
return;
Directory::UnsyncedMetaHandles handles;
{
ReadTransaction trans(dir, __FILE__, __LINE__);
dir->GetUnsyncedMetaHandles(&trans, &handles);
}
if (handles.empty())
return;
Directory::UnsyncedMetaHandles::iterator it;
for (it = handles.begin() ; it != handles.end() ; ++it) {
// Single transaction / entry we deal with.
WriteTransaction trans(dir, SYNCER, __FILE__, __LINE__);
MutableEntry entry(&trans, GET_BY_HANDLE, *it);
if (!entry.Get(IS_UNSYNCED) || !entry.Get(IS_DEL))
continue;
syncable::Id id = entry.Get(PARENT_ID);
while (id != trans.root_id()) {
if (deleted_folders->find(id) != deleted_folders->end()) {
// We've synced the deletion of this deleted entries parent.
entry.Put(IS_UNSYNCED, false);
break;
}
Entry parent(&trans, GET_BY_ID, id);
if (!parent.good() || !parent.Get(IS_DEL))
break;
id = parent.Get(PARENT_ID);
}
}
}
// static
VerifyResult SyncerUtil::VerifyNewEntry(
const SyncEntity& update,
syncable::Entry* target,
const bool deleted) {
if (target->good()) {
// Not a new update.
return VERIFY_UNDECIDED;
}
if (deleted) {
// Deletion of an item we've never seen can be ignored.
return VERIFY_SKIP;
}
return VERIFY_SUCCESS;
}
// Assumes we have an existing entry; check here for updates that break
// consistency rules.
// static
VerifyResult SyncerUtil::VerifyUpdateConsistency(
syncable::WriteTransaction* trans,
const SyncEntity& update,
syncable::MutableEntry* target,
const bool deleted,
const bool is_directory,
syncable::ModelType model_type) {
CHECK(target->good());
// If the update is a delete, we don't really need to worry at this stage.
if (deleted)
return VERIFY_SUCCESS;
if (model_type == syncable::UNSPECIFIED) {
// This update is to an item of a datatype we don't recognize. The server
// shouldn't have sent it to us. Throw it on the ground.
return VERIFY_SKIP;
}
if (target->Get(SERVER_VERSION) > 0) {
// Then we've had an update for this entry before.
if (is_directory != target->Get(SERVER_IS_DIR) ||
model_type != target->GetServerModelType()) {
if (target->Get(IS_DEL)) { // If we've deleted the item, we don't care.
return VERIFY_SKIP;
} else {
LOG(ERROR) << "Server update doesn't agree with previous updates. ";
LOG(ERROR) << " Entry: " << *target;
LOG(ERROR) << " Update: "
<< SyncerProtoUtil::SyncEntityDebugString(update);
return VERIFY_FAIL;
}
}
if (!deleted && (target->Get(ID) == update.id()) &&
(target->Get(SERVER_IS_DEL) ||
(!target->Get(IS_UNSYNCED) && target->Get(IS_DEL) &&
target->Get(BASE_VERSION) > 0))) {
// An undelete. The latter case in the above condition is for
// when the server does not give us an update following the
// commit of a delete, before undeleting.
// Undeletion is common for items that reuse the client-unique tag.
VerifyResult result =
SyncerUtil::VerifyUndelete(trans, update, target);
if (VERIFY_UNDECIDED != result)
return result;
}
}
if (target->Get(BASE_VERSION) > 0) {
// We've committed this update in the past.
if (is_directory != target->Get(IS_DIR) ||
model_type != target->GetModelType()) {
LOG(ERROR) << "Server update doesn't agree with committed item. ";
LOG(ERROR) << " Entry: " << *target;
LOG(ERROR) << " Update: "
<< SyncerProtoUtil::SyncEntityDebugString(update);
return VERIFY_FAIL;
}
if (target->Get(ID) == update.id()) {
// Checks that are only valid if we're not changing the ID.
if (target->Get(BASE_VERSION) == update.version() &&
!target->Get(IS_UNSYNCED) &&
!SyncerProtoUtil::Compare(*target, update)) {
// TODO(sync): This constraint needs to be relaxed. For now it's OK to
// fail the verification and deal with it when we ApplyUpdates.
LOG(ERROR) << "Server update doesn't match local data with same "
"version. A bug should be filed. Entry: " << *target <<
"Update: " << SyncerProtoUtil::SyncEntityDebugString(update);
return VERIFY_FAIL;
}
if (target->Get(SERVER_VERSION) > update.version()) {
LOG(WARNING) << "We've already seen a more recent version.";
LOG(WARNING) << " Entry: " << *target;
LOG(WARNING) << " Update: "
<< SyncerProtoUtil::SyncEntityDebugString(update);
return VERIFY_SKIP;
}
}
}
return VERIFY_SUCCESS;
}
// Assumes we have an existing entry; verify an update that seems to be
// expressing an 'undelete'
// static
VerifyResult SyncerUtil::VerifyUndelete(syncable::WriteTransaction* trans,
const SyncEntity& update,
syncable::MutableEntry* target) {
// TODO(nick): We hit this path for items deleted items that the server
// tells us to re-create; only deleted items with positive base versions
// will hit this path. However, it's not clear how such an undeletion
// would actually succeed on the server; in the protocol, a base
// version of 0 is required to undelete an object. This codepath
// should be deprecated in favor of client-tag style undeletion
// (where items go to version 0 when they're deleted), or else
// removed entirely (if this type of undeletion is indeed impossible).
CHECK(target->good());
VLOG(1) << "Server update is attempting undelete. " << *target
<< "Update:" << SyncerProtoUtil::SyncEntityDebugString(update);
// Move the old one aside and start over. It's too tricky to get the old one
// back into a state that would pass CheckTreeInvariants().
if (target->Get(IS_DEL)) {
DCHECK(target->Get(UNIQUE_CLIENT_TAG).empty())
<< "Doing move-aside undeletion on client-tagged item.";
target->Put(ID, trans->directory()->NextId());
target->Put(UNIQUE_CLIENT_TAG, "");
target->Put(BASE_VERSION, CHANGES_VERSION);
target->Put(SERVER_VERSION, 0);
return VERIFY_SUCCESS;
}
if (update.version() < target->Get(SERVER_VERSION)) {
LOG(WARNING) << "Update older than current server version for "
<< *target << " Update:"
<< SyncerProtoUtil::SyncEntityDebugString(update);
return VERIFY_SUCCESS; // Expected in new sync protocol.
}
return VERIFY_UNDECIDED;
}
} // namespace browser_sync