Roll DomDistillerJS

[chromium-blink-merge.git] / sync / engine / entity_tracker.cc

// Copyright 2014 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/entity_tracker.h"

#include "base/logging.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/syncable/syncable_util.h"
#include "sync/util/time.h"

namespace syncer {

EntityTracker* EntityTracker::FromServerUpdate(
    const std::string& id_string,
    const std::string& client_tag_hash,
    int64 received_version) {
  return new EntityTracker(id_string, client_tag_hash, 0, received_version);
}

EntityTracker* EntityTracker::FromCommitRequest(
    const std::string& id_string,
    const std::string& client_tag_hash,
    int64 sequence_number,
    int64 base_version,
    base::Time ctime,
    base::Time mtime,
    const std::string& non_unique_name,
    bool deleted,
    const sync_pb::EntitySpecifics& specifics) {
  return new EntityTracker(id_string,
                           client_tag_hash,
                           0,
                           0,
                           true,
                           sequence_number,
                           base_version,
                           ctime,
                           mtime,
                           non_unique_name,
                           deleted,
                           specifics);
}

// Constructor that does not set any pending commit fields.
EntityTracker::EntityTracker(const std::string& id,
                             const std::string& client_tag_hash,
                             int64 highest_commit_response_version,
                             int64 highest_gu_response_version)
    : id_(id),
      client_tag_hash_(client_tag_hash),
      highest_commit_response_version_(highest_commit_response_version),
      highest_gu_response_version_(highest_gu_response_version),
      is_commit_pending_(false),
      sequence_number_(0),
      base_version_(0),
      deleted_(false) {
}

EntityTracker::EntityTracker(const std::string& id,
                             const std::string& client_tag_hash,
                             int64 highest_commit_response_version,
                             int64 highest_gu_response_version,
                             bool is_commit_pending,
                             int64 sequence_number,
                             int64 base_version,
                             base::Time ctime,
                             base::Time mtime,
                             const std::string& non_unique_name,
                             bool deleted,
                             const sync_pb::EntitySpecifics& specifics)
    : id_(id),
      client_tag_hash_(client_tag_hash),
      highest_commit_response_version_(highest_commit_response_version),
      highest_gu_response_version_(highest_gu_response_version),
      is_commit_pending_(is_commit_pending),
      sequence_number_(sequence_number),
      base_version_(base_version),
      ctime_(ctime),
      mtime_(mtime),
      non_unique_name_(non_unique_name),
      deleted_(deleted),
      specifics_(specifics) {
}

EntityTracker::~EntityTracker() {
}

bool EntityTracker::IsCommitPending() const {
  return is_commit_pending_;
}

void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
                                       int64* sequence_number) const {
  // Set ID if we have a server-assigned ID.  Otherwise, it will be up to
  // our caller to assign a client-unique initial ID.
  if (base_version_ != kUncommittedVersion) {
    commit_entity->set_id_string(id_);
  }

  commit_entity->set_client_defined_unique_tag(client_tag_hash_);
  commit_entity->set_version(base_version_);
  commit_entity->set_deleted(deleted_);
  commit_entity->set_folder(false);
  commit_entity->set_name(non_unique_name_);
  if (!deleted_) {
    commit_entity->set_ctime(TimeToProtoTime(ctime_));
    commit_entity->set_mtime(TimeToProtoTime(mtime_));
    commit_entity->mutable_specifics()->CopyFrom(specifics_);
  }

  *sequence_number = sequence_number_;
}

void EntityTracker::RequestCommit(const std::string& id,
                                  const std::string& client_tag_hash,
                                  int64 sequence_number,
                                  int64 base_version,
                                  base::Time ctime,
                                  base::Time mtime,
                                  const std::string& non_unique_name,
                                  bool deleted,
                                  const sync_pb::EntitySpecifics& specifics) {
  DCHECK_GE(base_version, base_version_)
      << "Base version should never decrease";

  DCHECK_GE(sequence_number, sequence_number_)
      << "Sequence number should never decrease";

  // Update our book-keeping counters.
  base_version_ = base_version;
  sequence_number_ = sequence_number;

  // Do our counter values indicate a conflict?  If so, don't commit.
  //
  // There's no need to inform the model thread of the conflict.  The
  // conflicting update has already been posted to its task runner; it will
  // figure it out as soon as it runs that task.
  is_commit_pending_ = true;
  if (IsInConflict()) {
    ClearPendingCommit();
    return;
  }

  // We don't commit deletions of server-unknown items.
  if (deleted && !IsServerKnown()) {
    ClearPendingCommit();
    return;
  }

  // Otherwise, we should store the data associated with this pending commit
  // so we're ready to commit at the next possible opportunity.

  // We intentionally don't update the id_ here.  Good ID values come from the
  // server and always pass through the sync thread first.  There's no way the
  // model thread could have a better ID value than we do.

  // This entity is identified by its client tag.  That value can never change.
  DCHECK_EQ(client_tag_hash_, client_tag_hash);

  // Set the fields for the pending commit.
  ctime_ = ctime;
  mtime_ = mtime;
  non_unique_name_ = non_unique_name;
  deleted_ = deleted;
  specifics_ = specifics;
}

void EntityTracker::ReceiveCommitResponse(const std::string& response_id,
                                          int64 response_version,
                                          int64 sequence_number) {
  // Commit responses, especially after the first commit, can update our ID.
  id_ = response_id;

  DCHECK_GT(response_version, highest_commit_response_version_)
      << "Had expected higher response version."
      << " id: " << id_;

  // Commits are synchronous, so there's no reason why the sequence numbers
  // wouldn't match.
  DCHECK_EQ(sequence_number_, sequence_number)
      << "Unexpected sequence number mismatch."
      << " id: " << id_;

  highest_commit_response_version_ = response_version;

  // Because an in-progress commit blocks the sync thread, we can assume that
  // the item we just committed successfully is exactly the one we have now.
  // Nothing changed it while the commit was happening.  Since we're now in
  // sync with the server, we can clear the pending commit.
  ClearPendingCommit();
}

void EntityTracker::ReceiveUpdate(int64 version) {
  if (version <= highest_gu_response_version_)
    return;

  highest_gu_response_version_ = version;

  // Got an applicable update newer than any pending updates.  It must be safe
  // to discard the old pending update, if there was one.
  ClearPendingUpdate();

  if (IsInConflict()) {
    // Incoming update clobbers the pending commit on the sync thread.
    // The model thread can re-request this commit later if it wants to.
    ClearPendingCommit();
  }
}

bool EntityTracker::ReceivePendingUpdate(const UpdateResponseData& data) {
  if (data.response_version < highest_gu_response_version_)
    return false;

  highest_gu_response_version_ = data.response_version;
  pending_update_.reset(new UpdateResponseData(data));
  ClearPendingCommit();
  return true;
}

bool EntityTracker::HasPendingUpdate() const {
  return !!pending_update_;
}

UpdateResponseData EntityTracker::GetPendingUpdate() const {
  return *pending_update_;
}

void EntityTracker::ClearPendingUpdate() {
  pending_update_.reset();
}

bool EntityTracker::IsInConflict() const {
  if (!is_commit_pending_)
    return false;

  if (HasPendingUpdate())
    return true;

  if (highest_gu_response_version_ <= highest_commit_response_version_) {
    // The most recent server state was created in a commit made by this
    // client.  We're fully up to date, and therefore not in conflict.
    return false;
  } else {
    // The most recent server state was written by someone else.
    // Did the model thread have the most up to date version when it issued the
    // commit request?
    if (base_version_ >= highest_gu_response_version_) {
      return false;  // Yes.
    } else {
      return true;  // No.
    }
  }
}

bool EntityTracker::IsServerKnown() const {
  return base_version_ != kUncommittedVersion;
}

void EntityTracker::ClearPendingCommit() {
  is_commit_pending_ = false;

  // Clearing the specifics might free up some memory.  It can't hurt to try.
  specifics_.Clear();
}

}  // namespace syncer