chromium/src
0
Fork 0
Code Activity

move V2 classes in chrome/engine to syncer_v2 namespace

Browse Source 
BUG=516512

Review URL: https://codereview.chromium.org/1285443002

Cr-Commit-Position: refs/heads/master@{#343452}
This commit is contained in:
stanisc
2015-08-14 11:59:14 -07:00
committed by Commit bot
parent dd0208e170
commit 96665bd169
41 changed files with 459 additions and 543 deletions

2
chrome/browser/sync/profile_sync_service.cc

@ -432,7 +432,7 @@ void ProfileSyncService::RegisterNonBlockingType(syncer::ModelType type) {
void ProfileSyncService::InitializeNonBlockingType(
syncer::ModelType type,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) {
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_sync_proxy) {
non_blocking_data_type_manager_.InitializeType(
type, task_runner, type_sync_proxy);
}

2
chrome/browser/sync/profile_sync_service.h

@ -356,7 +356,7 @@ class ProfileSyncService : public sync_driver::SyncService,
void InitializeNonBlockingType(
syncer::ModelType type,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& proxy);
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy);
// Returns the SyncedWindowDelegatesGetter from the embedded sessions manager.
virtual browser_sync::SyncedWindowDelegatesGetter*

17
components/sync_driver/non_blocking_data_type_controller.cc

@ -21,7 +21,7 @@ NonBlockingDataTypeController::~NonBlockingDataTypeController() {}
void NonBlockingDataTypeController::InitializeType(
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) {
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_sync_proxy) {
DCHECK(!IsSyncProxyConnected());
task_runner_ = task_runner;
type_sync_proxy_ = type_sync_proxy;
@ -86,8 +86,7 @@ void NonBlockingDataTypeController::SendEnableSignal() {
task_runner_->PostTask(
FROM_HERE,
base::Bind(&syncer::ModelTypeSyncProxyImpl::Enable,
type_sync_proxy_,
base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::Enable, type_sync_proxy_,
base::Passed(sync_context_proxy_->Clone())));
current_state_ = ENABLED;
}
@ -95,9 +94,9 @@ void NonBlockingDataTypeController::SendEnableSignal() {
void NonBlockingDataTypeController::SendDisableSignal() {
DCHECK_EQ(DISABLED, GetDesiredState());
DVLOG(1) << "Disabling non-blocking sync type " << ModelTypeToString(type_);
task_runner_->PostTask(
FROM_HERE,
base::Bind(&syncer::ModelTypeSyncProxyImpl::Disable, type_sync_proxy_));
task_runner_->PostTask(FROM_HERE,
base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::Disable,
type_sync_proxy_));
current_state_ = DISABLED;
}
@ -105,9 +104,9 @@ void NonBlockingDataTypeController::SendDisconnectSignal() {
DCHECK_EQ(DISCONNECTED, GetDesiredState());
DVLOG(1) << "Disconnecting non-blocking sync type "
<< ModelTypeToString(type_);
task_runner_->PostTask(FROM_HERE,
base::Bind(&syncer::ModelTypeSyncProxyImpl::Disconnect,
type_sync_proxy_));
task_runner_->PostTask(
FROM_HERE, base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::Disconnect,
type_sync_proxy_));
current_state_ = DISCONNECTED;
}

4
components/sync_driver/non_blocking_data_type_controller.h

@ -63,7 +63,7 @@ class NonBlockingDataTypeController {
// will only ever deal with a single type proxy.
void InitializeType(
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy);
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_sync_proxy);
// Initialize the connection to the SyncContextProxy.
//
@ -125,7 +125,7 @@ class NonBlockingDataTypeController {
// The ModelTypeSyncProxyImpl and its associated thread. May be NULL.
scoped_refptr<base::SequencedTaskRunner> task_runner_;
base::WeakPtr<syncer::ModelTypeSyncProxyImpl> type_sync_proxy_;
base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl> type_sync_proxy_;
// The SyncContextProxy that connects to the current sync backend. May be
// NULL.

16
components/sync_driver/non_blocking_data_type_controller_unittest.cc

@ -22,7 +22,7 @@ namespace sync_driver {
namespace {
// A useless instance of ModelTypeSyncWorker.
class NullModelTypeSyncWorker : public syncer::ModelTypeSyncWorker {
class NullModelTypeSyncWorker : public syncer_v2::ModelTypeSyncWorker {
public:
NullModelTypeSyncWorker();
~NullModelTypeSyncWorker() override;
@ -47,14 +47,14 @@ class MockSyncContext {
void Connect(
syncer::ModelType type,
const scoped_refptr<base::SingleThreadTaskRunner>& model_task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_proxy) {
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_proxy) {
enabled_types_.Put(type);
model_task_runner->PostTask(
FROM_HERE,
base::Bind(&syncer::ModelTypeSyncProxyImpl::OnConnect,
type_proxy,
base::Passed(scoped_ptr<syncer::ModelTypeSyncWorker>(
new NullModelTypeSyncWorker()).Pass())));
base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnConnect, type_proxy,
base::Passed(scoped_ptr<syncer_v2::ModelTypeSyncWorker>(
new NullModelTypeSyncWorker())
.Pass())));
}
void Disconnect(syncer::ModelType type) {
@ -83,7 +83,7 @@ class MockSyncContextProxy : public syncer_v2::SyncContextProxy {
syncer::ModelType type,
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_proxy)
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_proxy)
override {
// Normally we'd use ThreadTaskRunnerHandle::Get() as the TaskRunner
// argument
@ -182,7 +182,7 @@ class NonBlockingDataTypeControllerTest : public testing::Test {
}
protected:
syncer::ModelTypeSyncProxyImpl type_sync_proxy_;
syncer_v2::ModelTypeSyncProxyImpl type_sync_proxy_;
scoped_refptr<base::TestSimpleTaskRunner> model_thread_;
scoped_refptr<base::TestSimpleTaskRunner> sync_thread_;

2
components/sync_driver/non_blocking_data_type_manager.cc

@ -29,7 +29,7 @@ void NonBlockingDataTypeManager::RegisterType(
void NonBlockingDataTypeManager::InitializeType(
syncer::ModelType type,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& proxy_impl) {
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy_impl) {
NonBlockingDataTypeControllerMap::const_iterator it =
non_blocking_data_type_controllers_.find(type);
DCHECK(it != non_blocking_data_type_controllers_.end());

7
components/sync_driver/non_blocking_data_type_manager.h

@ -15,11 +15,8 @@ namespace base {
class SequencedTaskRunner;
} // namespace base
namespace syncer {
class ModelTypeSyncProxyImpl;
} //namespace syncer
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
class SyncContextProxy;
} // namespace syncer_v2
@ -48,7 +45,7 @@ class NonBlockingDataTypeManager {
void InitializeType(
syncer::ModelType type,
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy);
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& type_sync_proxy);
// Connects the sync backend, as represented by a SyncContextProxy, to the
// NonBlockingDataTypeController on the UI thread.

17
sync/engine/entity_tracker.cc

@ -10,7 +10,7 @@
#include "sync/syncable/syncable_util.h"
#include "sync/util/time.h"
namespace syncer {
namespace syncer_v2 {
scoped_ptr<EntityTracker> EntityTracker::FromServerUpdate(
const std::string& id_string,
@ -87,7 +87,7 @@ 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_ != syncer_v2::kUncommittedVersion) {
if (base_version_ != kUncommittedVersion) {
commit_entity->set_id_string(id_);
}
@ -97,8 +97,8 @@ void EntityTracker::PrepareCommitProto(sync_pb::SyncEntity* commit_entity,
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->set_ctime(syncer::TimeToProtoTime(ctime_));
commit_entity->set_mtime(syncer::TimeToProtoTime(mtime_));
commit_entity->mutable_specifics()->CopyFrom(specifics_);
}
@ -201,13 +201,12 @@ void EntityTracker::ReceiveUpdate(int64 version) {
}
}
bool EntityTracker::ReceivePendingUpdate(
const syncer_v2::UpdateResponseData& data) {
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 syncer_v2::UpdateResponseData(data));
pending_update_.reset(new UpdateResponseData(data));
ClearPendingCommit();
return true;
}
@ -216,7 +215,7 @@ bool EntityTracker::HasPendingUpdate() const {
return !!pending_update_;
}
syncer_v2::UpdateResponseData EntityTracker::GetPendingUpdate() const {
UpdateResponseData EntityTracker::GetPendingUpdate() const {
return *pending_update_;
}
@ -248,7 +247,7 @@ bool EntityTracker::IsInConflict() const {
}
bool EntityTracker::IsServerKnown() const {
return base_version_ != syncer_v2::kUncommittedVersion;
return base_version_ != kUncommittedVersion;
}
void EntityTracker::ClearPendingCommit() {

9
sync/engine/entity_tracker.h

@ -15,9 +15,6 @@
namespace syncer_v2 {
struct UpdateResponseData;
} // namespace syncer_v2
namespace syncer {
// Manages the pending commit and update state for an entity on the sync
// thread.
@ -92,11 +89,11 @@ class SYNC_EXPORT EntityTracker {
// Returns true if the tracker decides this item is worth keeping. Returns
// false if the item is discarded, which could happen if the version number
// is out of date.
bool ReceivePendingUpdate(const syncer_v2::UpdateResponseData& data);
bool ReceivePendingUpdate(const UpdateResponseData& data);
// Functions to fetch the latest pending update.
bool HasPendingUpdate() const;
syncer_v2::UpdateResponseData GetPendingUpdate() const;
UpdateResponseData GetPendingUpdate() const;
// Clears the pending update. Allows us to resume regular commit behavior.
void ClearPendingUpdate();
@ -169,7 +166,7 @@ class SYNC_EXPORT EntityTracker {
// An update for this item which can't be applied right now. The presence of
// an pending update prevents commits. As of this writing, the only source
// of pending updates is updates we can't decrypt right now.
scoped_ptr<syncer_v2::UpdateResponseData> pending_update_;
scoped_ptr<UpdateResponseData> pending_update_;
DISALLOW_COPY_AND_ASSIGN(EntityTracker);
};

10
sync/engine/entity_tracker_unittest.cc

@ -12,7 +12,7 @@
#include "sync/util/time.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace syncer {
namespace syncer_v2 {
// Some simple tests for the EntityTracker.
//
@ -27,7 +27,9 @@ class EntityTrackerTest : public ::testing::Test {
EntityTrackerTest()
: kServerId("ServerID"),
kClientTag("some.sample.tag"),
kClientTagHash(syncable::GenerateSyncableHash(PREFERENCES, kClientTag)),
kClientTagHash(
syncer::syncable::GenerateSyncableHash(syncer::PREFERENCES,
kClientTag)),
kCtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(10)),
kMtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(20)) {
specifics.mutable_preference()->set_name(kClientTag);
@ -75,8 +77,8 @@ TEST_F(EntityTrackerTest, FromCommitRequest) {
EXPECT_EQ(kServerId, pb_entity.id_string());
EXPECT_EQ(kClientTagHash, pb_entity.client_defined_unique_tag());
EXPECT_EQ(33, pb_entity.version());
EXPECT_EQ(kCtime, ProtoTimeToTime(pb_entity.ctime()));
EXPECT_EQ(kMtime, ProtoTimeToTime(pb_entity.mtime()));
EXPECT_EQ(kCtime, syncer::ProtoTimeToTime(pb_entity.ctime()));
EXPECT_EQ(kMtime, syncer::ProtoTimeToTime(pb_entity.mtime()));
EXPECT_FALSE(pb_entity.deleted());
EXPECT_EQ(specifics.preference().name(),
pb_entity.specifics().preference().name());

12
sync/engine/model_type_entity.cc

@ -6,17 +6,17 @@
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/syncable/syncable_util.h"
namespace syncer {
namespace syncer_v2 {
scoped_ptr<ModelTypeEntity> ModelTypeEntity::NewLocalItem(
const std::string& client_tag,
const sync_pb::EntitySpecifics& specifics,
base::Time now) {
return scoped_ptr<ModelTypeEntity>(new ModelTypeEntity(
1, 0, 0, syncer_v2::kUncommittedVersion, true,
1, 0, 0, kUncommittedVersion, true,
std::string(), // Sync thread will assign the initial ID.
syncable::GenerateSyncableHash(GetModelTypeFromSpecifics(specifics),
client_tag),
syncer::syncable::GenerateSyncableHash(
syncer::GetModelTypeFromSpecifics(specifics), client_tag),
client_tag, // As non-unique name.
specifics, false, now, now, std::string()));
}
@ -139,7 +139,7 @@ void ModelTypeEntity::Delete() {
}
void ModelTypeEntity::InitializeCommitRequestData(
syncer_v2::CommitRequestData* request) const {
CommitRequestData* request) const {
request->id = id_;
request->client_tag_hash = client_tag_hash_;
request->sequence_number = sequence_number_;
@ -173,7 +173,7 @@ void ModelTypeEntity::ClearTransientSyncState() {
}
void ModelTypeEntity::ClearSyncState() {
base_version_ = syncer_v2::kUncommittedVersion;
base_version_ = kUncommittedVersion;
is_dirty_ = true;
sequence_number_ = 1;
commit_requested_sequence_number_ = 0;

5
sync/engine/model_type_entity.h

@ -14,9 +14,6 @@
namespace syncer_v2 {
struct CommitRequestData;
} // namespace syncer_v2
namespace syncer {
// This is the model thread's representation of a SyncEntity.
//
@ -99,7 +96,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeEntity {
// Initializes a message representing this item's uncommitted state
// to be forwarded to the sync server for committing.
void InitializeCommitRequestData(syncer_v2::CommitRequestData* request) const;
void InitializeCommitRequestData(CommitRequestData* request) const;
// Notes that the current version of this item has been queued for commit.
void SetCommitRequestInProgress();

6
sync/engine/model_type_entity_unittest.cc

@ -12,7 +12,7 @@
#include "testing/gtest/include/gtest/gtest.h"
namespace syncer {
namespace syncer_v2 {
// Some simple sanity tests for the ModelTypeEntity.
//
@ -28,7 +28,9 @@ class ModelTypeEntityTest : public ::testing::Test {
ModelTypeEntityTest()
: kServerId("ServerID"),
kClientTag("sample.pref.name"),
kClientTagHash(syncable::GenerateSyncableHash(PREFERENCES, kClientTag)),
kClientTagHash(
syncer::syncable::GenerateSyncableHash(syncer::PREFERENCES,
kClientTag)),
kCtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(10)),
kMtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(20)) {
sync_pb::PreferenceSpecifics* pref_specifics =

2
sync/engine/model_type_sync_proxy.cc

@ -4,7 +4,7 @@
#include "sync/engine/model_type_sync_proxy.h"
namespace syncer {
namespace syncer_v2 {
ModelTypeSyncProxy::ModelTypeSyncProxy() {
}

12
sync/engine/model_type_sync_proxy.h

@ -8,7 +8,7 @@
#include "sync/base/sync_export.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
namespace syncer_v2 {
// Interface used by sync backend to issue requests to a synced data type.
class SYNC_EXPORT_PRIVATE ModelTypeSyncProxy {
@ -17,12 +17,12 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxy {
virtual ~ModelTypeSyncProxy();
virtual void OnCommitCompleted(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list) = 0;
const DataTypeState& type_state,
const CommitResponseDataList& response_list) = 0;
virtual void OnUpdateReceived(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates) = 0;
const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates) = 0;
};
} // namespace syncer

60
sync/engine/model_type_sync_proxy_impl.cc

@ -11,15 +11,14 @@
#include "sync/internal_api/public/sync_context_proxy.h"
#include "sync/syncable/syncable_util.h"
namespace syncer {
namespace syncer_v2 {
ModelTypeSyncProxyImpl::ModelTypeSyncProxyImpl(ModelType type)
ModelTypeSyncProxyImpl::ModelTypeSyncProxyImpl(syncer::ModelType type)
: type_(type),
is_preferred_(false),
is_connected_(false),
weak_ptr_factory_for_ui_(this),
weak_ptr_factory_for_sync_(this) {
}
weak_ptr_factory_for_sync_(this) {}
ModelTypeSyncProxyImpl::~ModelTypeSyncProxyImpl() {
}
@ -34,13 +33,13 @@ bool ModelTypeSyncProxyImpl::IsConnected() const {
return is_connected_;
}
ModelType ModelTypeSyncProxyImpl::GetModelType() const {
syncer::ModelType ModelTypeSyncProxyImpl::GetModelType() const {
DCHECK(CalledOnValidThread());
return type_;
}
void ModelTypeSyncProxyImpl::Enable(
scoped_ptr<syncer_v2::SyncContextProxy> sync_context_proxy) {
scoped_ptr<SyncContextProxy> sync_context_proxy) {
DCHECK(CalledOnValidThread());
DVLOG(1) << "Asked to enable " << ModelTypeToString(type_);
@ -50,7 +49,7 @@ void ModelTypeSyncProxyImpl::Enable(
data_type_state_.progress_marker.set_data_type_id(
GetSpecificsFieldNumberFromModelType(type_));
syncer_v2::UpdateResponseDataList saved_pending_updates = GetPendingUpdates();
UpdateResponseDataList saved_pending_updates = GetPendingUpdates();
sync_context_proxy_ = sync_context_proxy.Pass();
sync_context_proxy_->ConnectTypeToSync(
GetModelType(),
@ -100,10 +99,10 @@ void ModelTypeSyncProxyImpl::OnConnect(scoped_ptr<ModelTypeSyncWorker> worker) {
void ModelTypeSyncProxyImpl::Put(const std::string& client_tag,
const sync_pb::EntitySpecifics& specifics) {
DCHECK_EQ(type_, GetModelTypeFromSpecifics(specifics));
DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(specifics));
const std::string client_tag_hash(
syncable::GenerateSyncableHash(type_, client_tag));
syncer::syncable::GenerateSyncableHash(type_, client_tag));
EntityMap::const_iterator it = entities_.find(client_tag_hash);
if (it == entities_.end()) {
@ -120,7 +119,7 @@ void ModelTypeSyncProxyImpl::Put(const std::string& client_tag,
void ModelTypeSyncProxyImpl::Delete(const std::string& client_tag) {
const std::string client_tag_hash(
syncable::GenerateSyncableHash(type_, client_tag));
syncer::syncable::GenerateSyncableHash(type_, client_tag));
EntityMap::const_iterator it = entities_.find(client_tag_hash);
if (it == entities_.end()) {
@ -137,7 +136,7 @@ void ModelTypeSyncProxyImpl::Delete(const std::string& client_tag) {
}
void ModelTypeSyncProxyImpl::FlushPendingCommitRequests() {
syncer_v2::CommitRequestDataList commit_requests;
CommitRequestDataList commit_requests;
// Don't bother sending anything if there's no one to send to.
if (!IsConnected())
@ -151,7 +150,7 @@ void ModelTypeSyncProxyImpl::FlushPendingCommitRequests() {
for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
++it) {
if (it->second->RequiresCommitRequest()) {
syncer_v2::CommitRequestData request;
CommitRequestData request;
it->second->InitializeCommitRequestData(&request);
commit_requests.push_back(request);
it->second->SetCommitRequestInProgress();
@ -163,14 +162,13 @@ void ModelTypeSyncProxyImpl::FlushPendingCommitRequests() {
}
void ModelTypeSyncProxyImpl::OnCommitCompleted(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list) {
const DataTypeState& type_state,
const CommitResponseDataList& response_list) {
data_type_state_ = type_state;
for (syncer_v2::CommitResponseDataList::const_iterator list_it =
response_list.begin();
for (CommitResponseDataList::const_iterator list_it = response_list.begin();
list_it != response_list.end(); ++list_it) {
const syncer_v2::CommitResponseData& response_data = *list_it;
const CommitResponseData& response_data = *list_it;
const std::string& client_tag_hash = response_data.client_tag_hash;
EntityMap::const_iterator it = entities_.find(client_tag_hash);
@ -188,18 +186,17 @@ void ModelTypeSyncProxyImpl::OnCommitCompleted(
}
void ModelTypeSyncProxyImpl::OnUpdateReceived(
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates) {
const DataTypeState& data_type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates) {
bool got_new_encryption_requirements = data_type_state_.encryption_key_name !=
data_type_state.encryption_key_name;
data_type_state_ = data_type_state;
for (syncer_v2::UpdateResponseDataList::const_iterator list_it =
response_list.begin();
for (UpdateResponseDataList::const_iterator list_it = response_list.begin();
list_it != response_list.end(); ++list_it) {
const syncer_v2::UpdateResponseData& response_data = *list_it;
const UpdateResponseData& response_data = *list_it;
const std::string& client_tag_hash = response_data.client_tag_hash;
// If we're being asked to apply an update to this entity, this overrides
@ -244,23 +241,20 @@ void ModelTypeSyncProxyImpl::OnUpdateReceived(
}
// Save pending updates in the appropriate data structure.
for (syncer_v2::UpdateResponseDataList::const_iterator list_it =
pending_updates.begin();
for (UpdateResponseDataList::const_iterator list_it = pending_updates.begin();
list_it != pending_updates.end(); ++list_it) {
const syncer_v2::UpdateResponseData& update = *list_it;
const UpdateResponseData& update = *list_it;
const std::string& client_tag_hash = update.client_tag_hash;
UpdateMap::const_iterator lookup_it =
pending_updates_map_.find(client_tag_hash);
if (lookup_it == pending_updates_map_.end()) {
pending_updates_map_.insert(
client_tag_hash,
make_scoped_ptr(new syncer_v2::UpdateResponseData(update)));
client_tag_hash, make_scoped_ptr(new UpdateResponseData(update)));
} else if (lookup_it->second->response_version <= update.response_version) {
pending_updates_map_.erase(lookup_it);
pending_updates_map_.insert(
client_tag_hash,
make_scoped_ptr(new syncer_v2::UpdateResponseData(update)));
client_tag_hash, make_scoped_ptr(new UpdateResponseData(update)));
} else {
// Received update is stale, do not overwrite existing.
}
@ -281,8 +275,8 @@ void ModelTypeSyncProxyImpl::OnUpdateReceived(
// TODO: Persist the new data on disk.
}
syncer_v2::UpdateResponseDataList ModelTypeSyncProxyImpl::GetPendingUpdates() {
syncer_v2::UpdateResponseDataList pending_updates_list;
UpdateResponseDataList ModelTypeSyncProxyImpl::GetPendingUpdates() {
UpdateResponseDataList pending_updates_list;
for (UpdateMap::const_iterator it = pending_updates_map_.begin();
it != pending_updates_map_.end();
++it) {
@ -304,7 +298,7 @@ void ModelTypeSyncProxyImpl::ClearSyncState() {
it->second->ClearSyncState();
}
pending_updates_map_.clear();
data_type_state_ = syncer_v2::DataTypeState();
data_type_state_ = DataTypeState();
}
} // namespace syncer

33
sync/engine/model_type_sync_proxy_impl.h

@ -16,10 +16,6 @@
namespace syncer_v2 {
class SyncContextProxy;
} // namespace syncer_v2
namespace syncer {
class ModelTypeEntity;
class ModelTypeSyncWorker;
@ -27,7 +23,7 @@ class ModelTypeSyncWorker;
// communication between sync and model type threads.
class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
public:
ModelTypeSyncProxyImpl(ModelType type);
ModelTypeSyncProxyImpl(syncer::ModelType type);
virtual ~ModelTypeSyncProxyImpl();
// Returns true if this object believes that sync is preferred for this type.
@ -46,10 +42,10 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
bool IsConnected() const;
// Returns the model type handled by this type sync proxy.
ModelType GetModelType() const;
syncer::ModelType GetModelType() const;
// Starts the handshake with the sync thread.
void Enable(scoped_ptr<syncer_v2::SyncContextProxy> context_proxy);
void Enable(scoped_ptr<SyncContextProxy> context_proxy);
// Severs all ties to the sync thread and may delete local sync state.
// Another call to Enable() can be used to re-establish this connection.
@ -71,16 +67,14 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
// Informs this object that some of its commit requests have been
// successfully serviced.
void OnCommitCompleted(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list);
void OnCommitCompleted(const DataTypeState& type_state,
const CommitResponseDataList& response_list);
// Informs this object that there are some incoming updates is should
// handle.
void OnUpdateReceived(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates);
void OnUpdateReceived(const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates);
// Returns the list of pending updates.
//
@ -88,7 +82,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
// The current test harness setup doesn't allow us to test the data that the
// proxy sends to the worker during initialization, so we use this to inspect
// its state instead.
syncer_v2::UpdateResponseDataList GetPendingUpdates();
UpdateResponseDataList GetPendingUpdates();
// Returns the long-lived WeakPtr that is intended to be registered with the
// ProfileSyncService.
@ -97,8 +91,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
private:
typedef base::ScopedPtrMap<std::string, scoped_ptr<ModelTypeEntity>>
EntityMap;
typedef base::ScopedPtrMap<std::string,
scoped_ptr<syncer_v2::UpdateResponseData>>
typedef base::ScopedPtrMap<std::string, scoped_ptr<UpdateResponseData>>
UpdateMap;
// Sends all commit requests that are due to be sent to the sync thread.
@ -113,8 +106,8 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
// account. Useful when a user signs out of the current account.
void ClearSyncState();
ModelType type_;
syncer_v2::DataTypeState data_type_state_;
syncer::ModelType type_;
DataTypeState data_type_state_;
// Whether or not sync is preferred for this type. This is a cached copy of
// the canonical copy information on the UI thread.
@ -129,7 +122,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncProxyImpl : base::NonThreadSafe {
//
// Beware of NULL pointers: This object is uninitialized when we are not
// connected to sync.
scoped_ptr<syncer_v2::SyncContextProxy> sync_context_proxy_;
scoped_ptr<SyncContextProxy> sync_context_proxy_;
// Reference to the ModelTypeSyncWorker.
//

111
sync/engine/model_type_sync_proxy_impl_unittest.cc

@ -14,9 +14,9 @@
#include "sync/test/engine/mock_model_type_sync_worker.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace syncer {
namespace syncer_v2 {
static const ModelType kModelType = PREFERENCES;
static const syncer::ModelType kModelType = syncer::PREFERENCES;
// Tests the sync engine parts of ModelTypeSyncProxyImpl.
//
@ -88,23 +88,21 @@ class ModelTypeSyncProxyImplTest : public ::testing::Test {
bool HasPendingUpdate(const std::string& tag) const;
// Returns the pending update with the specified tag.
syncer_v2::UpdateResponseData GetPendingUpdate(const std::string& tag) const;
UpdateResponseData GetPendingUpdate(const std::string& tag) const;
// Returns the number of pending updates.
size_t GetNumPendingUpdates() const;
// Read emitted commit requests as batches.
size_t GetNumCommitRequestLists();
syncer_v2::CommitRequestDataList GetNthCommitRequestList(size_t n);
CommitRequestDataList GetNthCommitRequestList(size_t n);
// Read emitted commit requests by tag, most recent only.
bool HasCommitRequestForTag(const std::string& tag);
syncer_v2::CommitRequestData GetLatestCommitRequestForTag(
const std::string& tag);
CommitRequestData GetLatestCommitRequestForTag(const std::string& tag);
// Sends the type sync proxy a successful commit response.
void SuccessfulCommitResponse(
const syncer_v2::CommitRequestData& request_data);
void SuccessfulCommitResponse(const CommitRequestData& request_data);
// Sends the type sync proxy an updated DataTypeState to let it know that
// the desired encryption key has changed.
@ -130,7 +128,7 @@ class ModelTypeSyncProxyImplTest : public ::testing::Test {
scoped_ptr<InjectableSyncContextProxy> injectable_sync_context_proxy_;
scoped_ptr<ModelTypeSyncProxyImpl> type_sync_proxy_;
syncer_v2::DataTypeState data_type_state_;
DataTypeState data_type_state_;
};
ModelTypeSyncProxyImplTest::ModelTypeSyncProxyImplTest()
@ -193,7 +191,7 @@ void ModelTypeSyncProxyImplTest::DeleteItem(const std::string& tag) {
void ModelTypeSyncProxyImplTest::OnInitialSyncDone() {
data_type_state_.initial_sync_done = true;
syncer_v2::UpdateResponseDataList empty_update_list;
UpdateResponseDataList empty_update_list;
type_sync_proxy_->OnUpdateReceived(
data_type_state_, empty_update_list, empty_update_list);
@ -203,13 +201,13 @@ void ModelTypeSyncProxyImplTest::UpdateFromServer(int64 version_offset,
const std::string& tag,
const std::string& value) {
const std::string tag_hash = GenerateTagHash(tag);
syncer_v2::UpdateResponseData data = mock_worker_->UpdateFromServer(
UpdateResponseData data = mock_worker_->UpdateFromServer(
version_offset, tag_hash, GenerateSpecifics(tag, value));
syncer_v2::UpdateResponseDataList list;
UpdateResponseDataList list;
list.push_back(data);
type_sync_proxy_->OnUpdateReceived(data_type_state_, list,
syncer_v2::UpdateResponseDataList());
UpdateResponseDataList());
}
void ModelTypeSyncProxyImplTest::PendingUpdateFromServer(
@ -218,14 +216,14 @@ void ModelTypeSyncProxyImplTest::PendingUpdateFromServer(
const std::string& value,
const std::string& key_name) {
const std::string tag_hash = GenerateTagHash(tag);
syncer_v2::UpdateResponseData data = mock_worker_->UpdateFromServer(
UpdateResponseData data = mock_worker_->UpdateFromServer(
version_offset, tag_hash,
GenerateEncryptedSpecifics(tag, value, key_name));
syncer_v2::UpdateResponseDataList list;
UpdateResponseDataList list;
list.push_back(data);
type_sync_proxy_->OnUpdateReceived(data_type_state_,
syncer_v2::UpdateResponseDataList(), list);
type_sync_proxy_->OnUpdateReceived(data_type_state_, UpdateResponseDataList(),
list);
}
void ModelTypeSyncProxyImplTest::TombstoneFromServer(int64 version_offset,
@ -233,21 +231,20 @@ void ModelTypeSyncProxyImplTest::TombstoneFromServer(int64 version_offset,
// Overwrite the existing server version if this is the new highest version.
std::string tag_hash = GenerateTagHash(tag);
syncer_v2::UpdateResponseData data =
UpdateResponseData data =
mock_worker_->TombstoneFromServer(version_offset, tag_hash);
syncer_v2::UpdateResponseDataList list;
UpdateResponseDataList list;
list.push_back(data);
type_sync_proxy_->OnUpdateReceived(data_type_state_, list,
syncer_v2::UpdateResponseDataList());
UpdateResponseDataList());
}
bool ModelTypeSyncProxyImplTest::HasPendingUpdate(
const std::string& tag) const {
const std::string client_tag_hash = GenerateTagHash(tag);
const syncer_v2::UpdateResponseDataList list =
type_sync_proxy_->GetPendingUpdates();
for (syncer_v2::UpdateResponseDataList::const_iterator it = list.begin();
const UpdateResponseDataList list = type_sync_proxy_->GetPendingUpdates();
for (UpdateResponseDataList::const_iterator it = list.begin();
it != list.end(); ++it) {
if (it->client_tag_hash == client_tag_hash)
return true;
@ -255,19 +252,18 @@ bool ModelTypeSyncProxyImplTest::HasPendingUpdate(
return false;
}
syncer_v2::UpdateResponseData ModelTypeSyncProxyImplTest::GetPendingUpdate(
UpdateResponseData ModelTypeSyncProxyImplTest::GetPendingUpdate(
const std::string& tag) const {
DCHECK(HasPendingUpdate(tag));
const std::string client_tag_hash = GenerateTagHash(tag);
const syncer_v2::UpdateResponseDataList list =
type_sync_proxy_->GetPendingUpdates();
for (syncer_v2::UpdateResponseDataList::const_iterator it = list.begin();
const UpdateResponseDataList list = type_sync_proxy_->GetPendingUpdates();
for (UpdateResponseDataList::const_iterator it = list.begin();
it != list.end(); ++it) {
if (it->client_tag_hash == client_tag_hash)
return *it;
}
NOTREACHED();
return syncer_v2::UpdateResponseData();
return UpdateResponseData();
}
size_t ModelTypeSyncProxyImplTest::GetNumPendingUpdates() const {
@ -275,8 +271,8 @@ size_t ModelTypeSyncProxyImplTest::GetNumPendingUpdates() const {
}
void ModelTypeSyncProxyImplTest::SuccessfulCommitResponse(
const syncer_v2::CommitRequestData& request_data) {
syncer_v2::CommitResponseDataList list;
const CommitRequestData& request_data) {
CommitResponseDataList list;
list.push_back(mock_worker_->SuccessfulCommitResponse(request_data));
type_sync_proxy_->OnCommitCompleted(data_type_state_, list);
}
@ -284,9 +280,8 @@ void ModelTypeSyncProxyImplTest::SuccessfulCommitResponse(
void ModelTypeSyncProxyImplTest::UpdateDesiredEncryptionKey(
const std::string& key_name) {
data_type_state_.encryption_key_name = key_name;
type_sync_proxy_->OnUpdateReceived(data_type_state_,
syncer_v2::UpdateResponseDataList(),
syncer_v2::UpdateResponseDataList());
type_sync_proxy_->OnUpdateReceived(data_type_state_, UpdateResponseDataList(),
UpdateResponseDataList());
}
void ModelTypeSyncProxyImplTest::SetServerEncryptionKey(
@ -296,7 +291,7 @@ void ModelTypeSyncProxyImplTest::SetServerEncryptionKey(
std::string ModelTypeSyncProxyImplTest::GenerateTagHash(
const std::string& tag) {
return syncable::GenerateSyncableHash(kModelType, tag);
return syncer::syncable::GenerateSyncableHash(kModelType, tag);
}
sync_pb::EntitySpecifics ModelTypeSyncProxyImplTest::GenerateSpecifics(
@ -315,7 +310,7 @@ sync_pb::EntitySpecifics ModelTypeSyncProxyImplTest::GenerateEncryptedSpecifics(
const std::string& value,
const std::string& key_name) {
sync_pb::EntitySpecifics specifics;
AddDefaultFieldValue(kModelType, &specifics);
syncer::AddDefaultFieldValue(kModelType, &specifics);
specifics.mutable_encrypted()->set_key_name(key_name);
specifics.mutable_encrypted()->set_blob("BLOB" + key_name);
return specifics;
@ -325,8 +320,8 @@ size_t ModelTypeSyncProxyImplTest::GetNumCommitRequestLists() {
return mock_worker_->GetNumCommitRequestLists();
}
syncer_v2::CommitRequestDataList
ModelTypeSyncProxyImplTest::GetNthCommitRequestList(size_t n) {
CommitRequestDataList ModelTypeSyncProxyImplTest::GetNthCommitRequestList(
size_t n) {
return mock_worker_->GetNthCommitRequestList(n);
}
@ -336,8 +331,7 @@ bool ModelTypeSyncProxyImplTest::HasCommitRequestForTag(
return mock_worker_->HasCommitRequestForTagHash(tag_hash);
}
syncer_v2::CommitRequestData
ModelTypeSyncProxyImplTest::GetLatestCommitRequestForTag(
CommitRequestData ModelTypeSyncProxyImplTest::GetLatestCommitRequestForTag(
const std::string& tag) {
const std::string tag_hash = GenerateTagHash(tag);
return mock_worker_->GetLatestCommitRequestForTagHash(tag_hash);
@ -354,11 +348,10 @@ TEST_F(ModelTypeSyncProxyImplTest, CreateLocalItem) {
// Verify the commit request this operation has triggered.
EXPECT_EQ(1U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_data = GetLatestCommitRequestForTag("tag1");
EXPECT_TRUE(tag1_data.id.empty());
EXPECT_EQ(syncer_v2::kUncommittedVersion, tag1_data.base_version);
EXPECT_EQ(kUncommittedVersion, tag1_data.base_version);
EXPECT_FALSE(tag1_data.ctime.is_null());
EXPECT_FALSE(tag1_data.mtime.is_null());
EXPECT_EQ("tag1", tag1_data.non_unique_name);
@ -376,15 +369,13 @@ TEST_F(ModelTypeSyncProxyImplTest, CreateAndModifyLocalItem) {
WriteItem("tag1", "value1");
EXPECT_EQ(1U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v1_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v1_data = GetLatestCommitRequestForTag("tag1");
WriteItem("tag1", "value2");
EXPECT_EQ(2U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v2_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v2_data = GetLatestCommitRequestForTag("tag1");
// Test some of the relations between old and new commit requests.
EXPECT_EQ(tag1_v1_data.specifics.preference().value(), "value1");
@ -392,7 +383,7 @@ TEST_F(ModelTypeSyncProxyImplTest, CreateAndModifyLocalItem) {
// Perform a thorough examination of the update-generated request.
EXPECT_TRUE(tag1_v2_data.id.empty());
EXPECT_EQ(syncer_v2::kUncommittedVersion, tag1_v2_data.base_version);
EXPECT_EQ(kUncommittedVersion, tag1_v2_data.base_version);
EXPECT_FALSE(tag1_v2_data.ctime.is_null());
EXPECT_FALSE(tag1_v2_data.mtime.is_null());
EXPECT_EQ("tag1", tag1_v2_data.non_unique_name);
@ -421,19 +412,17 @@ TEST_F(ModelTypeSyncProxyImplTest, DeleteServerUnknown) {
WriteItem("tag1", "value1");
EXPECT_EQ(1U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v1_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v1_data = GetLatestCommitRequestForTag("tag1");
DeleteItem("tag1");
EXPECT_EQ(2U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v2_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v2_data = GetLatestCommitRequestForTag("tag1");
EXPECT_GT(tag1_v2_data.sequence_number, tag1_v1_data.sequence_number);
EXPECT_TRUE(tag1_v2_data.id.empty());
EXPECT_EQ(syncer_v2::kUncommittedVersion, tag1_v2_data.base_version);
EXPECT_EQ(kUncommittedVersion, tag1_v2_data.base_version);
EXPECT_TRUE(tag1_v2_data.deleted);
}
@ -448,8 +437,7 @@ TEST_F(ModelTypeSyncProxyImplTest, DeleteServerUnknown_RacyCommitResponse) {
WriteItem("tag1", "value1");
EXPECT_EQ(1U, GetNumCommitRequestLists());
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v1_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v1_data = GetLatestCommitRequestForTag("tag1");
DeleteItem("tag1");
EXPECT_EQ(2U, GetNumCommitRequestLists());
@ -585,7 +573,7 @@ TEST_F(ModelTypeSyncProxyImplTest, ReceivePendingUpdates) {
PendingUpdateFromServer(5, "tag1", "value1", "key1");
EXPECT_EQ(1U, GetNumPendingUpdates());
ASSERT_TRUE(HasPendingUpdate("tag1"));
syncer_v2::UpdateResponseData data1 = GetPendingUpdate("tag1");
UpdateResponseData data1 = GetPendingUpdate("tag1");
EXPECT_EQ(5, data1.response_version);
// Receive an updated version of a pending update.
@ -593,7 +581,7 @@ TEST_F(ModelTypeSyncProxyImplTest, ReceivePendingUpdates) {
PendingUpdateFromServer(10, "tag1", "value15", "key1");
EXPECT_EQ(1U, GetNumPendingUpdates());
ASSERT_TRUE(HasPendingUpdate("tag1"));
syncer_v2::UpdateResponseData data2 = GetPendingUpdate("tag1");
UpdateResponseData data2 = GetPendingUpdate("tag1");
EXPECT_EQ(15, data2.response_version);
// Receive a stale version of a pending update.
@ -601,7 +589,7 @@ TEST_F(ModelTypeSyncProxyImplTest, ReceivePendingUpdates) {
PendingUpdateFromServer(-3, "tag1", "value12", "key1");
EXPECT_EQ(1U, GetNumPendingUpdates());
ASSERT_TRUE(HasPendingUpdate("tag1"));
syncer_v2::UpdateResponseData data3 = GetPendingUpdate("tag1");
UpdateResponseData data3 = GetPendingUpdate("tag1");
EXPECT_EQ(15, data3.response_version);
}
@ -642,8 +630,7 @@ TEST_F(ModelTypeSyncProxyImplTest, ReEncryptCommitsWithNewKey) {
// Commit an item.
WriteItem("tag1", "value1");
ASSERT_TRUE(HasCommitRequestForTag("tag1"));
const syncer_v2::CommitRequestData& tag1_v1_data =
GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag1_v1_data = GetLatestCommitRequestForTag("tag1");
SuccessfulCommitResponse(tag1_v1_data);
// Create another item and don't wait for its commit response.
@ -658,10 +645,8 @@ TEST_F(ModelTypeSyncProxyImplTest, ReEncryptCommitsWithNewKey) {
ASSERT_EQ(3U, GetNumCommitRequestLists());
EXPECT_EQ(2U, GetNthCommitRequestList(2).size());
const syncer_v2::CommitRequestData& tag1_enc =
GetLatestCommitRequestForTag("tag1");
const syncer_v2::CommitRequestData& tag2_enc =
GetLatestCommitRequestForTag("tag2");
const CommitRequestData& tag1_enc = GetLatestCommitRequestForTag("tag1");
const CommitRequestData& tag2_enc = GetLatestCommitRequestForTag("tag2");
SuccessfulCommitResponse(tag1_enc);
SuccessfulCommitResponse(tag2_enc);

2
sync/engine/model_type_sync_worker.cc

@ -4,7 +4,7 @@
#include "sync/engine/model_type_sync_worker.h"
namespace syncer {
namespace syncer_v2 {
ModelTypeSyncWorker::ModelTypeSyncWorker() {
}

5
sync/engine/model_type_sync_worker.h

@ -7,7 +7,7 @@
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
namespace syncer_v2 {
// Interface used by a synced data type to issue requests to the sync backend.
class SYNC_EXPORT_PRIVATE ModelTypeSyncWorker {
@ -16,8 +16,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeSyncWorker {
virtual ~ModelTypeSyncWorker();
// Entry point for the ModelTypeSyncProxy to send commit requests.
virtual void EnqueueForCommit(
const syncer_v2::CommitRequestDataList& list) = 0;
virtual void EnqueueForCommit(const CommitRequestDataList& list) = 0;
};
} // namespace syncer

61
sync/engine/model_type_sync_worker_impl.cc

@ -17,12 +17,18 @@
#include "sync/util/cryptographer.h"
#include "sync/util/time.h"
namespace syncer {
namespace syncer_v2 {
using syncer::CommitContribution;
using syncer::Cryptographer;
using syncer::ModelType;
using syncer::NudgeHandler;
using syncer::SyncerError;
ModelTypeSyncWorkerImpl::ModelTypeSyncWorkerImpl(
ModelType type,
const syncer_v2::DataTypeState& initial_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
const DataTypeState& initial_state,
const UpdateResponseDataList& saved_pending_updates,
scoped_ptr<Cryptographer> cryptographer,
NudgeHandler* nudge_handler,
scoped_ptr<ModelTypeSyncProxy> type_sync_proxy)
@ -37,7 +43,7 @@ ModelTypeSyncWorkerImpl::ModelTypeSyncWorkerImpl(
nudge_handler_->NudgeForInitialDownload(type_);
}
for (syncer_v2::UpdateResponseDataList::const_iterator it =
for (UpdateResponseDataList::const_iterator it =
saved_pending_updates.begin();
it != saved_pending_updates.end(); ++it) {
scoped_ptr<EntityTracker> entity_tracker = EntityTracker::FromServerUpdate(
@ -95,15 +101,15 @@ SyncerError ModelTypeSyncWorkerImpl::ProcessGetUpdatesResponse(
const sync_pb::DataTypeProgressMarker& progress_marker,
const sync_pb::DataTypeContext& mutated_context,
const SyncEntityList& applicable_updates,
sessions::StatusController* status) {
syncer::sessions::StatusController* status) {
DCHECK(CalledOnValidThread());
// TODO(rlarocque): Handle data type context conflicts.
data_type_state_.type_context = mutated_context;
data_type_state_.progress_marker = progress_marker;
syncer_v2::UpdateResponseDataList response_datas;
syncer_v2::UpdateResponseDataList pending_updates;
UpdateResponseDataList response_datas;
UpdateResponseDataList pending_updates;
for (SyncEntityList::const_iterator update_it = applicable_updates.begin();
update_it != applicable_updates.end();
@ -137,12 +143,12 @@ SyncerError ModelTypeSyncWorkerImpl::ProcessGetUpdatesResponse(
}
// Prepare the message for the model thread.
syncer_v2::UpdateResponseData response_data;
UpdateResponseData response_data;
response_data.id = update_entity->id_string();
response_data.client_tag_hash = client_tag_hash;
response_data.response_version = update_entity->version();
response_data.ctime = ProtoTimeToTime(update_entity->ctime());
response_data.mtime = ProtoTimeToTime(update_entity->mtime());
response_data.ctime = syncer::ProtoTimeToTime(update_entity->ctime());
response_data.mtime = syncer::ProtoTimeToTime(update_entity->mtime());
response_data.non_unique_name = update_entity->name();
response_data.deleted = update_entity->deleted();
@ -185,10 +191,11 @@ SyncerError ModelTypeSyncWorkerImpl::ProcessGetUpdatesResponse(
type_sync_proxy_->OnUpdateReceived(
data_type_state_, response_datas, pending_updates);
return SYNCER_OK;
return syncer::SYNCER_OK;
}
void ModelTypeSyncWorkerImpl::ApplyUpdates(sessions::StatusController* status) {
void ModelTypeSyncWorkerImpl::ApplyUpdates(
syncer::sessions::StatusController* status) {
DCHECK(CalledOnValidThread());
// This function is called only when we've finished a download cycle, ie. we
// got a response with changes_remaining == 0. If this is our first download
@ -199,28 +206,27 @@ void ModelTypeSyncWorkerImpl::ApplyUpdates(sessions::StatusController* status) {
data_type_state_.initial_sync_done = true;
type_sync_proxy_->OnUpdateReceived(data_type_state_,
syncer_v2::UpdateResponseDataList(),
syncer_v2::UpdateResponseDataList());
type_sync_proxy_->OnUpdateReceived(
data_type_state_, UpdateResponseDataList(), UpdateResponseDataList());
}
}
void ModelTypeSyncWorkerImpl::PassiveApplyUpdates(
sessions::StatusController* status) {
syncer::sessions::StatusController* status) {
NOTREACHED()
<< "Non-blocking types should never apply updates on sync thread. "
<< "ModelType is: " << ModelTypeToString(type_);
}
void ModelTypeSyncWorkerImpl::EnqueueForCommit(
const syncer_v2::CommitRequestDataList& list) {
const CommitRequestDataList& list) {
DCHECK(CalledOnValidThread());
DCHECK(IsTypeInitialized())
<< "Asked to commit items before type was initialized. "
<< "ModelType is: " << ModelTypeToString(type_);
for (syncer_v2::CommitRequestDataList::const_iterator it = list.begin();
for (CommitRequestDataList::const_iterator it = list.begin();
it != list.end(); ++it) {
StorePendingCommit(*it);
}
@ -266,9 +272,9 @@ scoped_ptr<CommitContribution> ModelTypeSyncWorkerImpl::GetContribution(
}
void ModelTypeSyncWorkerImpl::StorePendingCommit(
const syncer_v2::CommitRequestData& request) {
const CommitRequestData& request) {
if (!request.deleted) {
DCHECK_EQ(type_, GetModelTypeFromSpecifics(request.specifics));
DCHECK_EQ(type_, syncer::GetModelTypeFromSpecifics(request.specifics));
}
EntityMap::const_iterator map_it = entities_.find(request.client_tag_hash);
@ -293,8 +299,8 @@ void ModelTypeSyncWorkerImpl::StorePendingCommit(
}
void ModelTypeSyncWorkerImpl::OnCommitResponse(
const syncer_v2::CommitResponseDataList& response_list) {
for (syncer_v2::CommitResponseDataList::const_iterator response_it =
const CommitResponseDataList& response_list) {
for (CommitResponseDataList::const_iterator response_it =
response_list.begin();
response_it != response_list.end(); ++response_it) {
const std::string client_tag_hash = response_it->client_tag_hash;
@ -350,7 +356,7 @@ void ModelTypeSyncWorkerImpl::HelpInitializeCommitEntity(
// Initial commits need our help to generate a client ID.
if (!sync_entity->has_id_string()) {
DCHECK_EQ(syncer_v2::kUncommittedVersion, sync_entity->version());
DCHECK_EQ(kUncommittedVersion, sync_entity->version());
// TODO(stanisc): This is incorrect for bookmarks for two reasons:
// 1) Won't be able to match previously committed bookmarks to the ones
// with server ID.
@ -385,7 +391,7 @@ void ModelTypeSyncWorkerImpl::OnCryptographerUpdated() {
DCHECK(cryptographer_);
bool new_encryption_key = false;
syncer_v2::UpdateResponseDataList response_datas;
UpdateResponseDataList response_datas;
const std::string& new_key_name = cryptographer_->GetDefaultNigoriKeyName();
@ -400,15 +406,14 @@ void ModelTypeSyncWorkerImpl::OnCryptographerUpdated() {
for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
++it) {
if (it->second->HasPendingUpdate()) {
const syncer_v2::UpdateResponseData& saved_pending =
it->second->GetPendingUpdate();
const UpdateResponseData& saved_pending = it->second->GetPendingUpdate();
// We assume all pending updates are encrypted items for which we
// don't have the key.
DCHECK(saved_pending.specifics.has_encrypted());
if (cryptographer_->CanDecrypt(saved_pending.specifics.encrypted())) {
syncer_v2::UpdateResponseData decrypted_response = saved_pending;
UpdateResponseData decrypted_response = saved_pending;
if (DecryptSpecifics(cryptographer_.get(),
saved_pending.specifics,
&decrypted_response.specifics)) {
@ -428,7 +433,7 @@ void ModelTypeSyncWorkerImpl::OnCryptographerUpdated() {
"Delivering encryption key and %zd decrypted updates.",
response_datas.size());
type_sync_proxy_->OnUpdateReceived(data_type_state_, response_datas,
syncer_v2::UpdateResponseDataList());
UpdateResponseDataList());
}
}

51
sync/engine/model_type_sync_worker_impl.h

@ -24,7 +24,7 @@ namespace base {
class SingleThreadTaskRunner;
}
namespace syncer {
namespace syncer_v2 {
class ModelTypeSyncProxy;
class EntityTracker;
@ -49,46 +49,45 @@ class EntityTracker;
// example, if the sync server sends down an update for a sync entity that is
// currently pending for commit, this object will detect this condition and
// cancel the pending commit.
class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
public CommitContributor,
class SYNC_EXPORT ModelTypeSyncWorkerImpl : public syncer::UpdateHandler,
public syncer::CommitContributor,
public ModelTypeSyncWorker,
public base::NonThreadSafe {
public:
ModelTypeSyncWorkerImpl(
ModelType type,
const syncer_v2::DataTypeState& initial_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
scoped_ptr<Cryptographer> cryptographer,
NudgeHandler* nudge_handler,
scoped_ptr<ModelTypeSyncProxy> type_sync_proxy);
ModelTypeSyncWorkerImpl(syncer::ModelType type,
const DataTypeState& initial_state,
const UpdateResponseDataList& saved_pending_updates,
scoped_ptr<syncer::Cryptographer> cryptographer,
syncer::NudgeHandler* nudge_handler,
scoped_ptr<ModelTypeSyncProxy> type_sync_proxy);
~ModelTypeSyncWorkerImpl() override;
ModelType GetModelType() const;
syncer::ModelType GetModelType() const;
bool IsEncryptionRequired() const;
void UpdateCryptographer(scoped_ptr<Cryptographer> cryptographer);
void UpdateCryptographer(scoped_ptr<syncer::Cryptographer> cryptographer);
// UpdateHandler implementation.
void GetDownloadProgress(
sync_pb::DataTypeProgressMarker* progress_marker) const override;
void GetDataTypeContext(sync_pb::DataTypeContext* context) const override;
SyncerError ProcessGetUpdatesResponse(
syncer::SyncerError ProcessGetUpdatesResponse(
const sync_pb::DataTypeProgressMarker& progress_marker,
const sync_pb::DataTypeContext& mutated_context,
const SyncEntityList& applicable_updates,
sessions::StatusController* status) override;
void ApplyUpdates(sessions::StatusController* status) override;
void PassiveApplyUpdates(sessions::StatusController* status) override;
syncer::sessions::StatusController* status) override;
void ApplyUpdates(syncer::sessions::StatusController* status) override;
void PassiveApplyUpdates(syncer::sessions::StatusController* status) override;
// ModelTypeSyncWorker implementation.
void EnqueueForCommit(
const syncer_v2::CommitRequestDataList& request_list) override;
void EnqueueForCommit(const CommitRequestDataList& request_list) override;
// CommitContributor implementation.
scoped_ptr<CommitContribution> GetContribution(size_t max_entries) override;
scoped_ptr<syncer::CommitContribution> GetContribution(
size_t max_entries) override;
// Callback for when our contribution gets a response.
void OnCommitResponse(const syncer_v2::CommitResponseDataList& response_list);
void OnCommitResponse(const CommitResponseDataList& response_list);
base::WeakPtr<ModelTypeSyncWorkerImpl> AsWeakPtr();
@ -96,7 +95,7 @@ class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
typedef base::ScopedPtrMap<std::string, scoped_ptr<EntityTracker>> EntityMap;
// Stores a single commit request in this object's internal state.
void StorePendingCommit(const syncer_v2::CommitRequestData& request);
void StorePendingCommit(const CommitRequestData& request);
// Returns true if this type has successfully fetched all available updates
// from the server at least once. Our state may or may not be stale, but at
@ -129,14 +128,14 @@ class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
// In theory, this should never fail. Only corrupt or invalid entries could
// cause this to fail, and no clients are known to create such entries. The
// failure case is an attempt to be defensive against bad input.
static bool DecryptSpecifics(Cryptographer* cryptographer,
static bool DecryptSpecifics(syncer::Cryptographer* cryptographer,
const sync_pb::EntitySpecifics& in,
sync_pb::EntitySpecifics* out);
ModelType type_;
syncer::ModelType type_;
// State that applies to the entire model type.
syncer_v2::DataTypeState data_type_state_;
DataTypeState data_type_state_;
// Pointer to the ModelTypeSyncProxy associated with this worker.
// This is NULL when no proxy is connected..
@ -145,10 +144,10 @@ class SYNC_EXPORT ModelTypeSyncWorkerImpl : public UpdateHandler,
// A private copy of the most recent cryptographer known to sync.
// Initialized at construction time and updated with UpdateCryptographer().
// NULL if encryption is not enabled for this type.
scoped_ptr<Cryptographer> cryptographer_;
scoped_ptr<syncer::Cryptographer> cryptographer_;
// Interface used to access and send nudges to the sync scheduler. Not owned.
NudgeHandler* nudge_handler_;
syncer::NudgeHandler* nudge_handler_;
// A map of per-entity information known to this object.
//

142
sync/engine/model_type_sync_worker_impl_unittest.cc

@ -24,7 +24,13 @@ static const syncer::ModelType kModelType = syncer::PREFERENCES;
// Special constant value taken from cryptographer.cc.
const char kNigoriKeyName[] = "nigori-key";
namespace syncer {
namespace syncer_v2 {
using syncer::Cryptographer;
using syncer::CommitContribution;
using syncer::KeyParams;
using syncer::Nigori;
using syncer::sessions::StatusController;
// Tests the ModelTypeSyncWorkerImpl.
//
@ -72,12 +78,11 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
// Initialize with some saved pending updates from the model thread.
void InitializeWithPendingUpdates(
const syncer_v2::UpdateResponseDataList& initial_pending_updates);
const UpdateResponseDataList& initial_pending_updates);
// Initialize with a custom initial DataTypeState and pending updates.
void InitializeWithState(
const syncer_v2::DataTypeState& state,
const syncer_v2::UpdateResponseDataList& pending_updates);
void InitializeWithState(const DataTypeState& state,
const UpdateResponseDataList& pending_updates);
// Introduce a new key that the local cryptographer can't decrypt.
void NewForeignEncryptionKey();
@ -137,32 +142,29 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
// Note that if the model thread is in non-blocking mode, this data will not
// be updated until the response is actually processed by the model thread.
size_t GetNumModelThreadUpdateResponses() const;
syncer_v2::UpdateResponseDataList GetNthModelThreadUpdateResponse(
size_t n) const;
syncer_v2::UpdateResponseDataList GetNthModelThreadPendingUpdates(
size_t n) const;
syncer_v2::DataTypeState GetNthModelThreadUpdateState(size_t n) const;
UpdateResponseDataList GetNthModelThreadUpdateResponse(size_t n) const;
UpdateResponseDataList GetNthModelThreadPendingUpdates(size_t n) const;
DataTypeState GetNthModelThreadUpdateState(size_t n) const;
// Reads the latest update response datas on the model thread.
// Note that if the model thread is in non-blocking mode, this data will not
// be updated until the response is actually processed by the model thread.
bool HasUpdateResponseOnModelThread(const std::string& tag) const;
syncer_v2::UpdateResponseData GetUpdateResponseOnModelThread(
UpdateResponseData GetUpdateResponseOnModelThread(
const std::string& tag) const;
// Read the latest commit messages received on the model thread.
// Note that if the model thread is in non-blocking mode, this data will not
// be updated until the response is actually processed by the model thread.
size_t GetNumModelThreadCommitResponses() const;
syncer_v2::CommitResponseDataList GetNthModelThreadCommitResponse(
size_t n) const;
syncer_v2::DataTypeState GetNthModelThreadCommitState(size_t n) const;
CommitResponseDataList GetNthModelThreadCommitResponse(size_t n) const;
DataTypeState GetNthModelThreadCommitState(size_t n) const;
// Reads the latest commit response datas on the model thread.
// Note that if the model thread is in non-blocking mode, this data will not
// be updated until the response is actually processed by the model thread.
bool HasCommitResponseOnModelThread(const std::string& tag) const;
syncer_v2::CommitResponseData GetCommitResponseOnModelThread(
CommitResponseData GetCommitResponseOnModelThread(
const std::string& tag) const;
// Returns the number of commit nudges sent to the mock nudge handler.
@ -198,7 +200,7 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
private:
// An encryptor for our cryptographer.
FakeEncryptor fake_encryptor_;
syncer::FakeEncryptor fake_encryptor_;
// The cryptographer itself. NULL if we're not encrypting the type.
scoped_ptr<Cryptographer> cryptographer_;
@ -221,11 +223,11 @@ class ModelTypeSyncWorkerImplTest : public ::testing::Test {
// A mock that emulates enough of the sync server that it can be used
// a single UpdateHandler and CommitContributor pair. In this test
// harness, the |worker_| is both of them.
SingleTypeMockServer mock_server_;
syncer::SingleTypeMockServer mock_server_;
// A mock to track the number of times the ModelTypeSyncWorker requests to
// sync.
MockNudgeHandler mock_nudge_handler_;
syncer::MockNudgeHandler mock_nudge_handler_;
};
ModelTypeSyncWorkerImplTest::ModelTypeSyncWorkerImplTest()
@ -239,20 +241,20 @@ ModelTypeSyncWorkerImplTest::~ModelTypeSyncWorkerImplTest() {
}
void ModelTypeSyncWorkerImplTest::FirstInitialize() {
syncer_v2::DataTypeState initial_state;
DataTypeState initial_state;
initial_state.progress_marker.set_data_type_id(
GetSpecificsFieldNumberFromModelType(kModelType));
InitializeWithState(initial_state, syncer_v2::UpdateResponseDataList());
InitializeWithState(initial_state, UpdateResponseDataList());
}
void ModelTypeSyncWorkerImplTest::NormalInitialize() {
InitializeWithPendingUpdates(syncer_v2::UpdateResponseDataList());
InitializeWithPendingUpdates(UpdateResponseDataList());
}
void ModelTypeSyncWorkerImplTest::InitializeWithPendingUpdates(
const syncer_v2::UpdateResponseDataList& initial_pending_updates) {
syncer_v2::DataTypeState initial_state;
const UpdateResponseDataList& initial_pending_updates) {
DataTypeState initial_state;
initial_state.progress_marker.set_data_type_id(
GetSpecificsFieldNumberFromModelType(kModelType));
initial_state.progress_marker.set_token("some_saved_progress_token");
@ -265,8 +267,8 @@ void ModelTypeSyncWorkerImplTest::InitializeWithPendingUpdates(
}
void ModelTypeSyncWorkerImplTest::InitializeWithState(
const syncer_v2::DataTypeState& state,
const syncer_v2::UpdateResponseDataList& initial_pending_updates) {
const DataTypeState& state,
const UpdateResponseDataList& initial_pending_updates) {
DCHECK(!worker_);
// We don't get to own this object. The |worker_| keeps a scoped_ptr to it.
@ -328,7 +330,7 @@ void ModelTypeSyncWorkerImplTest::NewForeignEncryptionKey() {
// Update the worker with the latest cryptographer.
if (worker_) {
worker_->UpdateCryptographer(
make_scoped_ptr<Cryptographer>(new Cryptographer(*cryptographer_)));
make_scoped_ptr(new Cryptographer(*cryptographer_)));
}
}
@ -344,7 +346,7 @@ void ModelTypeSyncWorkerImplTest::UpdateLocalCryptographer() {
// Update the worker with the latest cryptographer.
if (worker_) {
worker_->UpdateCryptographer(
make_scoped_ptr<Cryptographer>(new Cryptographer(*cryptographer_)));
make_scoped_ptr(new Cryptographer(*cryptographer_)));
}
}
@ -355,18 +357,17 @@ void ModelTypeSyncWorkerImplTest::SetUpdateEncryptionFilter(int n) {
void ModelTypeSyncWorkerImplTest::CommitRequest(const std::string& name,
const std::string& value) {
const std::string tag_hash = GenerateTagHash(name);
syncer_v2::CommitRequestData data = mock_type_sync_proxy_->CommitRequest(
CommitRequestData data = mock_type_sync_proxy_->CommitRequest(
tag_hash, GenerateSpecifics(name, value));
syncer_v2::CommitRequestDataList list;
CommitRequestDataList list;
list.push_back(data);
worker_->EnqueueForCommit(list);
}
void ModelTypeSyncWorkerImplTest::DeleteRequest(const std::string& tag) {
const std::string tag_hash = GenerateTagHash(tag);
syncer_v2::CommitRequestData data =
mock_type_sync_proxy_->DeleteRequest(tag_hash);
syncer_v2::CommitRequestDataList list;
CommitRequestData data = mock_type_sync_proxy_->DeleteRequest(tag_hash);
CommitRequestDataList list;
list.push_back(data);
worker_->EnqueueForCommit(list);
}
@ -376,7 +377,7 @@ void ModelTypeSyncWorkerImplTest::TriggerTypeRootUpdateFromServer() {
SyncEntityList entity_list;
entity_list.push_back(&entity);
sessions::StatusController dummy_status;
StatusController dummy_status;
worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
mock_server_.GetContext(),
@ -400,7 +401,7 @@ void ModelTypeSyncWorkerImplTest::TriggerUpdateFromServer(
SyncEntityList entity_list;
entity_list.push_back(&entity);
sessions::StatusController dummy_status;
StatusController dummy_status;
worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
mock_server_.GetContext(),
@ -411,7 +412,7 @@ void ModelTypeSyncWorkerImplTest::TriggerUpdateFromServer(
void ModelTypeSyncWorkerImplTest::DeliverRawUpdates(
const SyncEntityList& list) {
sessions::StatusController dummy_status;
StatusController dummy_status;
worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
mock_server_.GetContext(),
list,
@ -433,7 +434,7 @@ void ModelTypeSyncWorkerImplTest::TriggerTombstoneFromServer(
SyncEntityList entity_list;
entity_list.push_back(&entity);
sessions::StatusController dummy_status;
StatusController dummy_status;
worker_->ProcessGetUpdatesResponse(mock_server_.GetProgress(),
mock_server_.GetContext(),
@ -478,7 +479,7 @@ void ModelTypeSyncWorkerImplTest::DoSuccessfulCommit() {
sync_pb::ClientToServerResponse response =
mock_server_.DoSuccessfulCommit(message);
sessions::StatusController dummy_status;
StatusController dummy_status;
contribution->ProcessCommitResponse(response, &dummy_status);
contribution->CleanUp();
}
@ -510,20 +511,20 @@ size_t ModelTypeSyncWorkerImplTest::GetNumModelThreadUpdateResponses() const {
return mock_type_sync_proxy_->GetNumUpdateResponses();
}
syncer_v2::UpdateResponseDataList
UpdateResponseDataList
ModelTypeSyncWorkerImplTest::GetNthModelThreadUpdateResponse(size_t n) const {
DCHECK_LT(n, GetNumModelThreadUpdateResponses());
return mock_type_sync_proxy_->GetNthUpdateResponse(n);
}
syncer_v2::UpdateResponseDataList
UpdateResponseDataList
ModelTypeSyncWorkerImplTest::GetNthModelThreadPendingUpdates(size_t n) const {
DCHECK_LT(n, GetNumModelThreadUpdateResponses());
return mock_type_sync_proxy_->GetNthPendingUpdates(n);
}
syncer_v2::DataTypeState
ModelTypeSyncWorkerImplTest::GetNthModelThreadUpdateState(size_t n) const {
DataTypeState ModelTypeSyncWorkerImplTest::GetNthModelThreadUpdateState(
size_t n) const {
DCHECK_LT(n, GetNumModelThreadUpdateResponses());
return mock_type_sync_proxy_->GetNthTypeStateReceivedInUpdateResponse(n);
}
@ -534,8 +535,7 @@ bool ModelTypeSyncWorkerImplTest::HasUpdateResponseOnModelThread(
return mock_type_sync_proxy_->HasUpdateResponse(tag_hash);
}
syncer_v2::UpdateResponseData
ModelTypeSyncWorkerImplTest::GetUpdateResponseOnModelThread(
UpdateResponseData ModelTypeSyncWorkerImplTest::GetUpdateResponseOnModelThread(
const std::string& tag) const {
const std::string tag_hash = GenerateTagHash(tag);
return mock_type_sync_proxy_->GetUpdateResponse(tag_hash);
@ -545,14 +545,14 @@ size_t ModelTypeSyncWorkerImplTest::GetNumModelThreadCommitResponses() const {
return mock_type_sync_proxy_->GetNumCommitResponses();
}
syncer_v2::CommitResponseDataList
CommitResponseDataList
ModelTypeSyncWorkerImplTest::GetNthModelThreadCommitResponse(size_t n) const {
DCHECK_LT(n, GetNumModelThreadCommitResponses());
return mock_type_sync_proxy_->GetNthCommitResponse(n);
}
syncer_v2::DataTypeState
ModelTypeSyncWorkerImplTest::GetNthModelThreadCommitState(size_t n) const {
DataTypeState ModelTypeSyncWorkerImplTest::GetNthModelThreadCommitState(
size_t n) const {
DCHECK_LT(n, GetNumModelThreadCommitResponses());
return mock_type_sync_proxy_->GetNthTypeStateReceivedInCommitResponse(n);
}
@ -563,8 +563,7 @@ bool ModelTypeSyncWorkerImplTest::HasCommitResponseOnModelThread(
return mock_type_sync_proxy_->HasCommitResponse(tag_hash);
}
syncer_v2::CommitResponseData
ModelTypeSyncWorkerImplTest::GetCommitResponseOnModelThread(
CommitResponseData ModelTypeSyncWorkerImplTest::GetCommitResponseOnModelThread(
const std::string& tag) const {
DCHECK(HasCommitResponseOnModelThread(tag));
const std::string tag_hash = GenerateTagHash(tag);
@ -591,7 +590,7 @@ std::string ModelTypeSyncWorkerImplTest::GetLocalCryptographerKeyName() const {
std::string ModelTypeSyncWorkerImplTest::GenerateTagHash(
const std::string& tag) {
const std::string& client_tag_hash =
syncable::GenerateSyncableHash(kModelType, tag);
syncer::syncable::GenerateSyncableHash(kModelType, tag);
return client_tag_hash;
}
@ -675,7 +674,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleCommit) {
ASSERT_TRUE(HasCommitEntityOnServer("tag1"));
const sync_pb::SyncEntity& entity = GetLatestCommitEntityOnServer("tag1");
EXPECT_FALSE(entity.id_string().empty());
EXPECT_EQ(syncer_v2::kUncommittedVersion, entity.version());
EXPECT_EQ(kUncommittedVersion, entity.version());
EXPECT_NE(0, entity.mtime());
EXPECT_NE(0, entity.ctime());
EXPECT_FALSE(entity.name().empty());
@ -688,7 +687,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleCommit) {
ASSERT_EQ(1U, GetNumModelThreadCommitResponses());
EXPECT_EQ(1U, GetNthModelThreadCommitResponse(0).size());
ASSERT_TRUE(HasCommitResponseOnModelThread("tag1"));
const syncer_v2::CommitResponseData& commit_response =
const CommitResponseData& commit_response =
GetCommitResponseOnModelThread("tag1");
// The ID changes in a commit response to initial commit.
@ -710,7 +709,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleDelete) {
DoSuccessfulCommit();
ASSERT_TRUE(HasCommitResponseOnModelThread("tag1"));
const syncer_v2::CommitResponseData& initial_commit_response =
const CommitResponseData& initial_commit_response =
GetCommitResponseOnModelThread("tag1");
int64 base_version = initial_commit_response.response_version;
@ -731,13 +730,13 @@ TEST_F(ModelTypeSyncWorkerImplTest, SimpleDelete) {
// Deletions should contain enough specifics to identify the type.
EXPECT_TRUE(entity.has_specifics());
EXPECT_EQ(kModelType, GetModelTypeFromSpecifics(entity.specifics()));
EXPECT_EQ(kModelType, syncer::GetModelTypeFromSpecifics(entity.specifics()));
// Verify the commit response returned to the model thread.
ASSERT_EQ(2U, GetNumModelThreadCommitResponses());
EXPECT_EQ(1U, GetNthModelThreadCommitResponse(1).size());
ASSERT_TRUE(HasCommitResponseOnModelThread("tag1"));
const syncer_v2::CommitResponseData& commit_response =
const CommitResponseData& commit_response =
GetCommitResponseOnModelThread("tag1");
EXPECT_EQ(entity.id_string(), commit_response.id);
@ -781,7 +780,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, SendInitialSyncDone) {
EXPECT_EQ(0U, GetNthModelThreadUpdateResponse(0).size());
EXPECT_EQ(0U, GetNthModelThreadUpdateResponse(1).size());
const syncer_v2::DataTypeState& state = GetNthModelThreadUpdateState(1);
const DataTypeState& state = GetNthModelThreadUpdateState(1);
EXPECT_FALSE(state.progress_marker.token().empty());
EXPECT_TRUE(state.initial_sync_done);
}
@ -835,12 +834,11 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUpdates) {
TriggerUpdateFromServer(10, "tag1", "value1");
ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
syncer_v2::UpdateResponseDataList updates_list =
GetNthModelThreadUpdateResponse(0);
UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
ASSERT_EQ(1U, updates_list.size());
ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
syncer_v2::UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
EXPECT_FALSE(update.id.empty());
EXPECT_EQ(tag_hash, update.client_tag_hash);
@ -932,8 +930,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveDecryptableEntities) {
// Test some basic properties regarding the update.
ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
syncer_v2::UpdateResponseData update1 =
GetUpdateResponseOnModelThread("tag1");
UpdateResponseData update1 = GetUpdateResponseOnModelThread("tag1");
EXPECT_EQ("tag1", update1.specifics.preference().name());
EXPECT_EQ("value1", update1.specifics.preference().value());
EXPECT_TRUE(update1.encryption_key_name.empty());
@ -946,8 +943,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveDecryptableEntities) {
// Test its basic features and the value of encryption_key_name.
ASSERT_TRUE(HasUpdateResponseOnModelThread("tag2"));
syncer_v2::UpdateResponseData update2 =
GetUpdateResponseOnModelThread("tag2");
UpdateResponseData update2 = GetUpdateResponseOnModelThread("tag2");
EXPECT_EQ("tag2", update2.specifics.preference().name());
EXPECT_EQ("value2", update2.specifics.preference().value());
EXPECT_FALSE(update2.encryption_key_name.empty());
@ -986,17 +982,15 @@ TEST_F(ModelTypeSyncWorkerImplTest, ReceiveUndecryptableEntries) {
// updates will be undecryptable. They'll be transfered to the model thread
// for safe-keeping as pending updates.
ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
syncer_v2::UpdateResponseDataList updates_list =
GetNthModelThreadUpdateResponse(0);
UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
EXPECT_EQ(0U, updates_list.size());
syncer_v2::UpdateResponseDataList pending_updates =
GetNthModelThreadPendingUpdates(0);
UpdateResponseDataList pending_updates = GetNthModelThreadPendingUpdates(0);
EXPECT_EQ(1U, pending_updates.size());
// The update will be delivered as soon as decryption becomes possible.
UpdateLocalCryptographer();
ASSERT_TRUE(HasUpdateResponseOnModelThread("tag1"));
syncer_v2::UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
UpdateResponseData update = GetUpdateResponseOnModelThread("tag1");
EXPECT_EQ("tag1", update.specifics.preference().name());
EXPECT_EQ("value1", update.specifics.preference().value());
EXPECT_FALSE(update.encryption_key_name.empty());
@ -1019,18 +1013,16 @@ TEST_F(ModelTypeSyncWorkerImplTest, EncryptedUpdateOverridesPendingCommit) {
// The encrypted update will be delivered to the model thread.
ASSERT_EQ(1U, GetNumModelThreadUpdateResponses());
syncer_v2::UpdateResponseDataList updates_list =
GetNthModelThreadUpdateResponse(0);
UpdateResponseDataList updates_list = GetNthModelThreadUpdateResponse(0);
EXPECT_EQ(0U, updates_list.size());
syncer_v2::UpdateResponseDataList pending_updates =
GetNthModelThreadPendingUpdates(0);
UpdateResponseDataList pending_updates = GetNthModelThreadPendingUpdates(0);
EXPECT_EQ(1U, pending_updates.size());
}
// Test decryption of pending updates saved across a restart.
TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
// Create a fake pending update.
syncer_v2::UpdateResponseData update;
UpdateResponseData update;
update.client_tag_hash = GenerateTagHash("tag1");
update.id = "SomeID";
@ -1044,7 +1036,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestorePendingEntries) {
EncryptUpdate(GetNthKeyParams(1), &(update.specifics));
// Inject the update during ModelTypeSyncWorker initialization.
syncer_v2::UpdateResponseDataList saved_pending_updates;
UpdateResponseDataList saved_pending_updates;
saved_pending_updates.push_back(update);
InitializeWithPendingUpdates(saved_pending_updates);
@ -1069,7 +1061,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestoreApplicableEntries) {
UpdateLocalCryptographer();
// Create a fake pending update.
syncer_v2::UpdateResponseData update;
UpdateResponseData update;
update.client_tag_hash = GenerateTagHash("tag1");
update.id = "SomeID";
update.response_version = 100;
@ -1082,7 +1074,7 @@ TEST_F(ModelTypeSyncWorkerImplTest, RestoreApplicableEntries) {
EncryptUpdate(GetNthKeyParams(1), &(update.specifics));
// Inject the update during ModelTypeSyncWorker initialization.
syncer_v2::UpdateResponseDataList saved_pending_updates;
UpdateResponseDataList saved_pending_updates;
saved_pending_updates.push_back(update);
InitializeWithPendingUpdates(saved_pending_updates);

26
sync/engine/non_blocking_type_commit_contribution.cc

@ -9,7 +9,7 @@
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/protocol/proto_value_conversions.h"
namespace syncer {
namespace syncer_v2 {
NonBlockingTypeCommitContribution::NonBlockingTypeCommitContribution(
const sync_pb::DataTypeContext& context,
@ -39,16 +39,16 @@ void NonBlockingTypeCommitContribution::AddToCommitMessage(
commit_message->add_client_contexts()->CopyFrom(context_);
}
SyncerError NonBlockingTypeCommitContribution::ProcessCommitResponse(
syncer::SyncerError NonBlockingTypeCommitContribution::ProcessCommitResponse(
const sync_pb::ClientToServerResponse& response,
sessions::StatusController* status) {
syncer::sessions::StatusController* status) {
const sync_pb::CommitResponse& commit_response = response.commit();
bool transient_error = false;
bool commit_conflict = false;
bool unknown_error = false;
syncer_v2::CommitResponseDataList response_list;
CommitResponseDataList response_list;
for (size_t i = 0; i < sequence_numbers_.size(); ++i) {
const sync_pb::CommitResponse_EntryResponse& entry_response =
@ -57,18 +57,18 @@ SyncerError NonBlockingTypeCommitContribution::ProcessCommitResponse(
switch (entry_response.response_type()) {
case sync_pb::CommitResponse::INVALID_MESSAGE:
LOG(ERROR) << "Server reports commit message is invalid.";
DLOG(ERROR) << "Message was: " << SyncEntityToValue(entities_.Get(i),
false);
DLOG(ERROR) << "Message was: "
<< syncer::SyncEntityToValue(entities_.Get(i), false);
unknown_error = true;
break;
case sync_pb::CommitResponse::CONFLICT:
DVLOG(1) << "Server reports conflict for commit message.";
DVLOG(1) << "Message was: " << SyncEntityToValue(entities_.Get(i),
false);
DVLOG(1) << "Message was: "
<< syncer::SyncEntityToValue(entities_.Get(i), false);
commit_conflict = true;
break;
case sync_pb::CommitResponse::SUCCESS: {
syncer_v2::CommitResponseData response_data;
CommitResponseData response_data;
response_data.id = entry_response.id_string();
response_data.client_tag_hash =
entities_.Get(i).client_defined_unique_tag();
@ -95,13 +95,13 @@ SyncerError NonBlockingTypeCommitContribution::ProcessCommitResponse(
// Let the scheduler know about the failures.
if (unknown_error) {
return SERVER_RETURN_UNKNOWN_ERROR;
return syncer::SERVER_RETURN_UNKNOWN_ERROR;
} else if (transient_error) {
return SERVER_RETURN_TRANSIENT_ERROR;
return syncer::SERVER_RETURN_TRANSIENT_ERROR;
} else if (commit_conflict) {
return SERVER_RETURN_CONFLICT;
return syncer::SERVER_RETURN_CONFLICT;
} else {
return SYNCER_OK;
return syncer::SYNCER_OK;
}
}

8
sync/engine/non_blocking_type_commit_contribution.h

@ -11,7 +11,7 @@
#include "sync/engine/commit_contribution.h"
#include "sync/protocol/sync.pb.h"
namespace syncer {
namespace syncer_v2 {
class ModelTypeSyncWorkerImpl;
@ -19,7 +19,7 @@ class ModelTypeSyncWorkerImpl;
//
// Helps build a commit message and process its response. It collaborates
// closely with the ModelTypeSyncWorkerImpl.
class NonBlockingTypeCommitContribution : public CommitContribution {
class NonBlockingTypeCommitContribution : public syncer::CommitContribution {
public:
NonBlockingTypeCommitContribution(
const sync_pb::DataTypeContext& context,
@ -30,9 +30,9 @@ class NonBlockingTypeCommitContribution : public CommitContribution {
// Implementation of CommitContribution
void AddToCommitMessage(sync_pb::ClientToServerMessage* msg) override;
SyncerError ProcessCommitResponse(
syncer::SyncerError ProcessCommitResponse(
const sync_pb::ClientToServerResponse& response,
sessions::StatusController* status) override;
syncer::sessions::StatusController* status) override;
void CleanUp() override;
size_t GetNumEntries() const override;

8
sync/internal_api/public/sync_context.h

@ -12,11 +12,9 @@
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
class ModelTypeSyncProxyImpl;
}
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
// An interface of the core parts of sync.
//
// In theory, this is the component that provides off-thread sync types with
@ -38,7 +36,7 @@ class SYNC_EXPORT_PRIVATE SyncContext {
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const scoped_refptr<base::SequencedTaskRunner>& datatype_task_runner,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) = 0;
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) = 0;
// Disconnects the syncer from the model and stops syncing the type.
//

7
sync/internal_api/public/sync_context_proxy.h

@ -9,11 +9,8 @@
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
class ModelTypeSyncProxyImpl;
}
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
// Interface for the datatype integration logic from non-sync threads.
//
@ -30,7 +27,7 @@ class SYNC_EXPORT_PRIVATE SyncContextProxy {
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) = 0;
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) = 0;
// Tells the syncer that we're no longer interested in syncing this type.
//

16
sync/internal_api/public/test/null_sync_context_proxy.h

@ -9,11 +9,9 @@
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/internal_api/public/sync_context_proxy.h"
namespace syncer {
class ModelTypeSyncProxyImpl;
}
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
// A non-functional implementation of SyncContextProxy.
//
// It supports Clone(), but not much else. Useful for testing.
@ -22,11 +20,11 @@ class NullSyncContextProxy : public SyncContextProxy {
NullSyncContextProxy();
~NullSyncContextProxy() override;
void ConnectTypeToSync(syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>&
type_sync_proxy) override;
void ConnectTypeToSync(
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) override;
void Disconnect(syncer::ModelType type) override;
scoped_ptr<SyncContextProxy> Clone() const override;
};

2
sync/internal_api/sync_context_proxy_impl.cc

@ -26,7 +26,7 @@ void SyncContextProxyImpl::ConnectTypeToSync(
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) {
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) {
VLOG(1) << "ConnectTypeToSync: " << ModelTypeToString(type);
sync_task_runner_->PostTask(FROM_HERE,
base::Bind(&SyncContext::ConnectSyncTypeToWorker,

16
sync/internal_api/sync_context_proxy_impl.h

@ -12,12 +12,8 @@
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/sync_context_proxy.h"
namespace syncer {
class ModelTypeSyncProxyImpl;
}
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
class SyncContext;
struct DataTypeState;
@ -40,11 +36,11 @@ class SYNC_EXPORT_PRIVATE SyncContextProxyImpl : public SyncContextProxy {
// unable to distinguish a slow success from failure.
//
// Must be called from the thread where the data type lives.
void ConnectTypeToSync(syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>&
sync_proxy_impl) override;
void ConnectTypeToSync(
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& pending_updates,
const base::WeakPtr<ModelTypeSyncProxyImpl>& sync_proxy_impl) override;
// Disables syncing for the given type on the sync thread.
void Disconnect(syncer::ModelType type) override;

12
sync/internal_api/sync_context_proxy_impl_unittest.cc

@ -58,7 +58,7 @@ class SyncContextProxyImplTest : public ::testing::Test {
// Try to connect a type to a SyncContext that has already shut down.
TEST_F(SyncContextProxyImplTest, FailToConnect1) {
syncer::ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
DisableSync();
themes_sync_proxy.Enable(GetProxy());
@ -69,7 +69,7 @@ TEST_F(SyncContextProxyImplTest, FailToConnect1) {
// Try to connect a type to a SyncContext as it shuts down.
TEST_F(SyncContextProxyImplTest, FailToConnect2) {
syncer::ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
ModelTypeSyncProxyImpl themes_sync_proxy(syncer::THEMES);
themes_sync_proxy.Enable(GetProxy());
DisableSync();
@ -80,8 +80,8 @@ TEST_F(SyncContextProxyImplTest, FailToConnect2) {
// Tests the case where the type's sync proxy shuts down first.
TEST_F(SyncContextProxyImplTest, TypeDisconnectsFirst) {
scoped_ptr<syncer::ModelTypeSyncProxyImpl> themes_sync_proxy(
new syncer::ModelTypeSyncProxyImpl(syncer::THEMES));
scoped_ptr<ModelTypeSyncProxyImpl> themes_sync_proxy(
new ModelTypeSyncProxyImpl(syncer::THEMES));
themes_sync_proxy->Enable(GetProxy());
base::RunLoop run_loop_;
@ -93,8 +93,8 @@ TEST_F(SyncContextProxyImplTest, TypeDisconnectsFirst) {
// Tests the case where the sync thread shuts down first.
TEST_F(SyncContextProxyImplTest, SyncDisconnectsFirst) {
scoped_ptr<syncer::ModelTypeSyncProxyImpl> themes_sync_proxy(
new syncer::ModelTypeSyncProxyImpl(syncer::THEMES));
scoped_ptr<ModelTypeSyncProxyImpl> themes_sync_proxy(
new ModelTypeSyncProxyImpl(syncer::THEMES));
themes_sync_proxy->Enable(GetProxy());
base::RunLoop run_loop_;

2
sync/internal_api/test/null_sync_context_proxy.cc

@ -16,7 +16,7 @@ void NullSyncContextProxy::ConnectTypeToSync(
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& saved_pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) {
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) {
NOTREACHED() << "NullSyncContextProxy is not meant to be used";
}

77
sync/sessions/model_type_registry.cc

@ -21,10 +21,10 @@ namespace syncer {
namespace {
class ModelTypeSyncProxyWrapper : public ModelTypeSyncProxy {
class ModelTypeSyncProxyWrapper : public syncer_v2::ModelTypeSyncProxy {
public:
ModelTypeSyncProxyWrapper(
const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
~ModelTypeSyncProxyWrapper() override;
@ -37,15 +37,14 @@ class ModelTypeSyncProxyWrapper : public ModelTypeSyncProxy {
const syncer_v2::UpdateResponseDataList& pending_updates) override;
private:
base::WeakPtr<ModelTypeSyncProxyImpl> processor_;
base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl> processor_;
scoped_refptr<base::SequencedTaskRunner> processor_task_runner_;
};
ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner)
: processor_(proxy), processor_task_runner_(processor_task_runner) {
}
: processor_(proxy), processor_task_runner_(processor_task_runner) {}
ModelTypeSyncProxyWrapper::~ModelTypeSyncProxyWrapper() {
}
@ -55,10 +54,8 @@ void ModelTypeSyncProxyWrapper::OnCommitCompleted(
const syncer_v2::CommitResponseDataList& response_list) {
processor_task_runner_->PostTask(
FROM_HERE,
base::Bind(&ModelTypeSyncProxyImpl::OnCommitCompleted,
processor_,
type_state,
response_list));
base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnCommitCompleted,
processor_, type_state, response_list));
}
void ModelTypeSyncProxyWrapper::OnUpdateReceived(
@ -67,32 +64,28 @@ void ModelTypeSyncProxyWrapper::OnUpdateReceived(
const syncer_v2::UpdateResponseDataList& pending_updates) {
processor_task_runner_->PostTask(
FROM_HERE,
base::Bind(&ModelTypeSyncProxyImpl::OnUpdateReceived,
processor_,
type_state,
response_list,
pending_updates));
base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnUpdateReceived,
processor_, type_state, response_list, pending_updates));
}
class ModelTypeSyncWorkerWrapper : public ModelTypeSyncWorker {
class ModelTypeSyncWorkerWrapper : public syncer_v2::ModelTypeSyncWorker {
public:
ModelTypeSyncWorkerWrapper(
const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
~ModelTypeSyncWorkerWrapper() override;
void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override;
private:
base::WeakPtr<ModelTypeSyncWorkerImpl> worker_;
base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl> worker_;
scoped_refptr<base::SequencedTaskRunner> sync_thread_;
};
ModelTypeSyncWorkerWrapper::ModelTypeSyncWorkerWrapper(
const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
const scoped_refptr<base::SequencedTaskRunner>& sync_thread)
: worker_(worker), sync_thread_(sync_thread) {
}
: worker_(worker), sync_thread_(sync_thread) {}
ModelTypeSyncWorkerWrapper::~ModelTypeSyncWorkerWrapper() {
}
@ -101,7 +94,8 @@ void ModelTypeSyncWorkerWrapper::EnqueueForCommit(
const syncer_v2::CommitRequestDataList& list) {
sync_thread_->PostTask(
FROM_HERE,
base::Bind(&ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_, list));
base::Bind(&syncer_v2::ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_,
list));
}
} // namespace
@ -192,33 +186,29 @@ void ModelTypeRegistry::ConnectSyncTypeToWorker(
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy_impl) {
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy_impl) {
DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
// Initialize Worker -> Proxy communication channel.
scoped_ptr<ModelTypeSyncProxy> proxy(
scoped_ptr<syncer_v2::ModelTypeSyncProxy> proxy(
new ModelTypeSyncProxyWrapper(proxy_impl, type_task_runner));
scoped_ptr<Cryptographer> cryptographer_copy;
if (encrypted_types_.Has(type))
cryptographer_copy.reset(new Cryptographer(*cryptographer_));
scoped_ptr<ModelTypeSyncWorkerImpl> worker(
new ModelTypeSyncWorkerImpl(type,
data_type_state,
saved_pending_updates,
cryptographer_copy.Pass(),
nudge_handler_,
proxy.Pass()));
scoped_ptr<syncer_v2::ModelTypeSyncWorkerImpl> worker(
new syncer_v2::ModelTypeSyncWorkerImpl(
type, data_type_state, saved_pending_updates,
cryptographer_copy.Pass(), nudge_handler_, proxy.Pass()));
// Initialize Proxy -> Worker communication channel.
scoped_ptr<ModelTypeSyncWorker> wrapped_worker(
scoped_ptr<syncer_v2::ModelTypeSyncWorker> wrapped_worker(
new ModelTypeSyncWorkerWrapper(worker->AsWeakPtr(),
scoped_refptr<base::SequencedTaskRunner>(
base::ThreadTaskRunnerHandle::Get())));
type_task_runner->PostTask(FROM_HERE,
base::Bind(&ModelTypeSyncProxyImpl::OnConnect,
proxy_impl,
base::Passed(&wrapped_worker)));
type_task_runner->PostTask(
FROM_HERE, base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnConnect,
proxy_impl, base::Passed(&wrapped_worker)));
DCHECK(update_handler_map_.find(type) == update_handler_map_.end());
DCHECK(commit_contributor_map_.find(type) == commit_contributor_map_.end());
@ -245,10 +235,9 @@ void ModelTypeRegistry::DisconnectSyncWorker(ModelType type) {
DCHECK_EQ(1U, committers_erased);
// Remove from the ScopedVector, deleting the worker in the process.
for (ScopedVector<ModelTypeSyncWorkerImpl>::iterator it =
for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
model_type_sync_workers_.begin();
it != model_type_sync_workers_.end();
++it) {
it != model_type_sync_workers_.end(); ++it) {
if ((*it)->GetModelType() == type) {
model_type_sync_workers_.erase(it);
break;
@ -344,10 +333,9 @@ ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
}
void ModelTypeRegistry::OnEncryptionStateChanged() {
for (ScopedVector<ModelTypeSyncWorkerImpl>::iterator it =
for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
model_type_sync_workers_.begin();
it != model_type_sync_workers_.end();
++it) {
it != model_type_sync_workers_.end(); ++it) {
if (encrypted_types_.Has((*it)->GetModelType())) {
(*it)->UpdateCryptographer(
make_scoped_ptr(new Cryptographer(*cryptographer_)));
@ -357,10 +345,9 @@ void ModelTypeRegistry::OnEncryptionStateChanged() {
ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const {
ModelTypeSet enabled_off_thread_types;
for (ScopedVector<ModelTypeSyncWorkerImpl>::const_iterator it =
for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::const_iterator it =
model_type_sync_workers_.begin();
it != model_type_sync_workers_.end();
++it) {
it != model_type_sync_workers_.end(); ++it) {
enabled_off_thread_types.Put((*it)->GetModelType());
}
return enabled_off_thread_types;

8
sync/sessions/model_type_registry.h

@ -22,6 +22,8 @@
namespace syncer_v2 {
struct DataTypeState;
class ModelTypeSyncWorkerImpl;
class ModelTypeSyncProxyImpl;
}
namespace syncer {
@ -34,8 +36,6 @@ class CommitContributor;
class DirectoryCommitContributor;
class DirectoryUpdateHandler;
class DirectoryTypeDebugInfoEmitter;
class ModelTypeSyncWorkerImpl;
class ModelTypeSyncProxyImpl;
class UpdateHandler;
typedef std::map<ModelType, UpdateHandler*> UpdateHandlerMap;
@ -66,7 +66,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& saved_pending_updates,
const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy) override;
const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy) override;
// Disables the syncing of an off-thread type.
//
@ -120,7 +120,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry
ScopedVector<DirectoryTypeDebugInfoEmitter>
directory_type_debug_info_emitters_;
ScopedVector<ModelTypeSyncWorkerImpl> model_type_sync_workers_;
ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl> model_type_sync_workers_;
// Maps of UpdateHandlers and CommitContributors.
// They do not own any of the objects they point to.

2
sync/sessions/model_type_registry_unittest.cc

@ -17,6 +17,8 @@
namespace syncer {
using syncer_v2::ModelTypeSyncProxyImpl;
class ModelTypeRegistryTest : public ::testing::Test {
public:
ModelTypeRegistryTest();

14
sync/test/engine/injectable_sync_context_proxy.cc

@ -7,7 +7,7 @@
#include "sync/engine/model_type_sync_proxy_impl.h"
#include "sync/engine/model_type_sync_worker.h"
namespace syncer {
namespace syncer_v2 {
InjectableSyncContextProxy::InjectableSyncContextProxy(
ModelTypeSyncWorker* worker)
@ -19,9 +19,9 @@ InjectableSyncContextProxy::~InjectableSyncContextProxy() {
void InjectableSyncContextProxy::ConnectTypeToSync(
syncer::ModelType type,
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy) {
const DataTypeState& data_type_state,
const UpdateResponseDataList& response_list,
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) {
// This class is allowed to participate in only one connection.
DCHECK(!is_worker_connected_);
is_worker_connected_ = true;
@ -38,11 +38,9 @@ void InjectableSyncContextProxy::Disconnect(syncer::ModelType type) {
worker_ = NULL;
}
scoped_ptr<syncer_v2::SyncContextProxy> InjectableSyncContextProxy::Clone()
const {
scoped_ptr<SyncContextProxy> InjectableSyncContextProxy::Clone() const {
// This confuses ownership. We trust that our callers are well-behaved.
return scoped_ptr<syncer_v2::SyncContextProxy>(
new InjectableSyncContextProxy(worker_));
return scoped_ptr<SyncContextProxy>(new InjectableSyncContextProxy(worker_));
}
ModelTypeSyncWorker* InjectableSyncContextProxy::GetWorker() {

17
sync/test/engine/injectable_sync_context_proxy.h

@ -9,26 +9,25 @@
#include "sync/internal_api/public/non_blocking_sync_common.h"
#include "sync/internal_api/public/sync_context_proxy.h"
namespace syncer {
namespace syncer_v2 {
class ModelTypeSyncProxyImpl;
class ModelTypeSyncWorker;
// A SyncContextProxy implementation that, when a connection request is made,
// initalizes a connection to a previously injected ModelTypeSyncProxyImpl.
class InjectableSyncContextProxy : public syncer_v2::SyncContextProxy {
class InjectableSyncContextProxy : public SyncContextProxy {
public:
explicit InjectableSyncContextProxy(ModelTypeSyncWorker* worker);
~InjectableSyncContextProxy() override;
void ConnectTypeToSync(
ModelType type,
const syncer_v2::DataTypeState& data_type_state,
const syncer_v2::UpdateResponseDataList& pending_updates,
const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& type_sync_proxy)
override;
void Disconnect(ModelType type) override;
scoped_ptr<syncer_v2::SyncContextProxy> Clone() const override;
syncer::ModelType type,
const DataTypeState& data_type_state,
const UpdateResponseDataList& pending_updates,
const base::WeakPtr<ModelTypeSyncProxyImpl>& type_sync_proxy) override;
void Disconnect(syncer::ModelType type) override;
scoped_ptr<SyncContextProxy> Clone() const override;
ModelTypeSyncWorker* GetWorker();

70
sync/test/engine/mock_model_type_sync_proxy.cc

@ -6,7 +6,7 @@
#include "base/bind.h"
namespace syncer {
namespace syncer_v2 {
MockModelTypeSyncProxy::MockModelTypeSyncProxy() : is_synchronous_(true) {
}
@ -15,8 +15,8 @@ MockModelTypeSyncProxy::~MockModelTypeSyncProxy() {
}
void MockModelTypeSyncProxy::OnCommitCompleted(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list) {
const DataTypeState& type_state,
const CommitResponseDataList& response_list) {
base::Closure task =
base::Bind(&MockModelTypeSyncProxy::OnCommitCompletedImpl,
base::Unretained(this),
@ -28,9 +28,9 @@ void MockModelTypeSyncProxy::OnCommitCompleted(
}
void MockModelTypeSyncProxy::OnUpdateReceived(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates) {
const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates) {
base::Closure task = base::Bind(&MockModelTypeSyncProxy::OnUpdateReceivedImpl,
base::Unretained(this),
type_state,
@ -54,12 +54,12 @@ void MockModelTypeSyncProxy::RunQueuedTasks() {
pending_tasks_.clear();
}
syncer_v2::CommitRequestData MockModelTypeSyncProxy::CommitRequest(
CommitRequestData MockModelTypeSyncProxy::CommitRequest(
const std::string& tag_hash,
const sync_pb::EntitySpecifics& specifics) {
const int64 base_version = GetBaseVersion(tag_hash);
syncer_v2::CommitRequestData data;
CommitRequestData data;
if (HasServerAssignedId(tag_hash)) {
data.id = GetServerAssignedId(tag_hash);
@ -80,10 +80,10 @@ syncer_v2::CommitRequestData MockModelTypeSyncProxy::CommitRequest(
return data;
}
syncer_v2::CommitRequestData MockModelTypeSyncProxy::DeleteRequest(
CommitRequestData MockModelTypeSyncProxy::DeleteRequest(
const std::string& tag_hash) {
const int64 base_version = GetBaseVersion(tag_hash);
syncer_v2::CommitRequestData data;
CommitRequestData data;
if (HasServerAssignedId(tag_hash)) {
data.id = GetServerAssignedId(tag_hash);
@ -107,20 +107,19 @@ size_t MockModelTypeSyncProxy::GetNumUpdateResponses() const {
return received_update_responses_.size();
}
syncer_v2::UpdateResponseDataList MockModelTypeSyncProxy::GetNthUpdateResponse(
UpdateResponseDataList MockModelTypeSyncProxy::GetNthUpdateResponse(
size_t n) const {
DCHECK_LT(n, GetNumUpdateResponses());
return received_update_responses_[n];
}
syncer_v2::UpdateResponseDataList MockModelTypeSyncProxy::GetNthPendingUpdates(
UpdateResponseDataList MockModelTypeSyncProxy::GetNthPendingUpdates(
size_t n) const {
DCHECK_LT(n, GetNumUpdateResponses());
return received_pending_updates_[n];
}
syncer_v2::DataTypeState
MockModelTypeSyncProxy::GetNthTypeStateReceivedInUpdateResponse(
DataTypeState MockModelTypeSyncProxy::GetNthTypeStateReceivedInUpdateResponse(
size_t n) const {
DCHECK_LT(n, GetNumUpdateResponses());
return type_states_received_on_update_[n];
@ -130,14 +129,13 @@ size_t MockModelTypeSyncProxy::GetNumCommitResponses() const {
return received_commit_responses_.size();
}
syncer_v2::CommitResponseDataList MockModelTypeSyncProxy::GetNthCommitResponse(
CommitResponseDataList MockModelTypeSyncProxy::GetNthCommitResponse(
size_t n) const {
DCHECK_LT(n, GetNumCommitResponses());
return received_commit_responses_[n];
}
syncer_v2::DataTypeState
MockModelTypeSyncProxy::GetNthTypeStateReceivedInCommitResponse(
DataTypeState MockModelTypeSyncProxy::GetNthTypeStateReceivedInCommitResponse(
size_t n) const {
DCHECK_LT(n, GetNumCommitResponses());
return type_states_received_on_commit_[n];
@ -145,41 +143,40 @@ MockModelTypeSyncProxy::GetNthTypeStateReceivedInCommitResponse(
bool MockModelTypeSyncProxy::HasUpdateResponse(
const std::string& tag_hash) const {
std::map<const std::string, syncer_v2::UpdateResponseData>::const_iterator
it = update_response_items_.find(tag_hash);
std::map<const std::string, UpdateResponseData>::const_iterator it =
update_response_items_.find(tag_hash);
return it != update_response_items_.end();
}
syncer_v2::UpdateResponseData MockModelTypeSyncProxy::GetUpdateResponse(
UpdateResponseData MockModelTypeSyncProxy::GetUpdateResponse(
const std::string& tag_hash) const {
DCHECK(HasUpdateResponse(tag_hash));
std::map<const std::string, syncer_v2::UpdateResponseData>::const_iterator
it = update_response_items_.find(tag_hash);
std::map<const std::string, UpdateResponseData>::const_iterator it =
update_response_items_.find(tag_hash);
return it->second;
}
bool MockModelTypeSyncProxy::HasCommitResponse(
const std::string& tag_hash) const {
std::map<const std::string, syncer_v2::CommitResponseData>::const_iterator
it = commit_response_items_.find(tag_hash);
std::map<const std::string, CommitResponseData>::const_iterator it =
commit_response_items_.find(tag_hash);
return it != commit_response_items_.end();
}
syncer_v2::CommitResponseData MockModelTypeSyncProxy::GetCommitResponse(
CommitResponseData MockModelTypeSyncProxy::GetCommitResponse(
const std::string& tag_hash) const {
DCHECK(HasCommitResponse(tag_hash));
std::map<const std::string, syncer_v2::CommitResponseData>::const_iterator
it = commit_response_items_.find(tag_hash);
std::map<const std::string, CommitResponseData>::const_iterator it =
commit_response_items_.find(tag_hash);
return it->second;
}
void MockModelTypeSyncProxy::OnCommitCompletedImpl(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list) {
const DataTypeState& type_state,
const CommitResponseDataList& response_list) {
received_commit_responses_.push_back(response_list);
type_states_received_on_commit_.push_back(type_state);
for (syncer_v2::CommitResponseDataList::const_iterator it =
response_list.begin();
for (CommitResponseDataList::const_iterator it = response_list.begin();
it != response_list.end(); ++it) {
commit_response_items_.insert(std::make_pair(it->client_tag_hash, *it));
@ -190,14 +187,13 @@ void MockModelTypeSyncProxy::OnCommitCompletedImpl(
}
void MockModelTypeSyncProxy::OnUpdateReceivedImpl(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates) {
const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates) {
received_update_responses_.push_back(response_list);
received_pending_updates_.push_back(pending_updates);
type_states_received_on_update_.push_back(type_state);
for (syncer_v2::UpdateResponseDataList::const_iterator it =
response_list.begin();
for (UpdateResponseDataList::const_iterator it = response_list.begin();
it != response_list.end(); ++it) {
update_response_items_.insert(std::make_pair(it->client_tag_hash, *it));
@ -234,7 +230,7 @@ int64 MockModelTypeSyncProxy::GetBaseVersion(
std::map<const std::string, int64>::const_iterator it =
base_versions_.find(tag_hash);
if (it == base_versions_.end()) {
return syncer_v2::kUncommittedVersion;
return kUncommittedVersion;
} else {
return it->second;
}

67
sync/test/engine/mock_model_type_sync_proxy.h

@ -12,7 +12,7 @@
#include "sync/engine/model_type_sync_proxy.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
namespace syncer_v2 {
// Mocks the ModelTypeSyncProxy.
//
@ -31,13 +31,11 @@ class MockModelTypeSyncProxy : public ModelTypeSyncProxy {
~MockModelTypeSyncProxy() override;
// Implementation of ModelTypeSyncProxy.
void OnCommitCompleted(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list) override;
void OnUpdateReceived(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates) override;
void OnCommitCompleted(const DataTypeState& type_state,
const CommitResponseDataList& response_list) override;
void OnUpdateReceived(const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates) override;
// By default, this object behaves as if all messages are processed
// immediately. Sometimes it is useful to defer work until later, as might
@ -57,53 +55,46 @@ class MockModelTypeSyncProxy : public ModelTypeSyncProxy {
// directly to its attached ModelTypeSyncWorker. These methods
// return the value to the caller so the test framework can handle them as it
// sees fit.
syncer_v2::CommitRequestData CommitRequest(
const std::string& tag_hash,
const sync_pb::EntitySpecifics& specifics);
syncer_v2::CommitRequestData DeleteRequest(const std::string& tag_hash);
CommitRequestData CommitRequest(const std::string& tag_hash,
const sync_pb::EntitySpecifics& specifics);
CommitRequestData DeleteRequest(const std::string& tag_hash);
// Getters to access the log of received update responses.
//
// Does not includes repsonses that are in pending tasks.
size_t GetNumUpdateResponses() const;
syncer_v2::UpdateResponseDataList GetNthUpdateResponse(size_t n) const;
syncer_v2::UpdateResponseDataList GetNthPendingUpdates(size_t n) const;
syncer_v2::DataTypeState GetNthTypeStateReceivedInUpdateResponse(
size_t n) const;
UpdateResponseDataList GetNthUpdateResponse(size_t n) const;
UpdateResponseDataList GetNthPendingUpdates(size_t n) const;
DataTypeState GetNthTypeStateReceivedInUpdateResponse(size_t n) const;
// Getters to access the log of received commit responses.
//
// Does not includes repsonses that are in pending tasks.
size_t GetNumCommitResponses() const;
syncer_v2::CommitResponseDataList GetNthCommitResponse(size_t n) const;
syncer_v2::DataTypeState GetNthTypeStateReceivedInCommitResponse(
size_t n) const;
CommitResponseDataList GetNthCommitResponse(size_t n) const;
DataTypeState GetNthTypeStateReceivedInCommitResponse(size_t n) const;
// Getters to access the lastest update response for a given tag_hash.
bool HasUpdateResponse(const std::string& tag_hash) const;
syncer_v2::UpdateResponseData GetUpdateResponse(
const std::string& tag_hash) const;
UpdateResponseData GetUpdateResponse(const std::string& tag_hash) const;
// Getters to access the lastest commit response for a given tag_hash.
bool HasCommitResponse(const std::string& tag_hash) const;
syncer_v2::CommitResponseData GetCommitResponse(
const std::string& tag_hash) const;
CommitResponseData GetCommitResponse(const std::string& tag_hash) const;
private:
// Process a received commit response.
//
// Implemented as an Impl method so we can defer its execution in some cases.
void OnCommitCompletedImpl(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::CommitResponseDataList& response_list);
void OnCommitCompletedImpl(const DataTypeState& type_state,
const CommitResponseDataList& response_list);
// Process a received update response.
//
// Implemented as an Impl method so we can defer its execution in some cases.
void OnUpdateReceivedImpl(
const syncer_v2::DataTypeState& type_state,
const syncer_v2::UpdateResponseDataList& response_list,
const syncer_v2::UpdateResponseDataList& pending_updates);
void OnUpdateReceivedImpl(const DataTypeState& type_state,
const UpdateResponseDataList& response_list,
const UpdateResponseDataList& pending_updates);
// Getter and setter for per-item sequence number tracking.
int64 GetCurrentSequenceNumber(const std::string& tag_hash) const;
@ -124,17 +115,15 @@ class MockModelTypeSyncProxy : public ModelTypeSyncProxy {
std::vector<base::Closure> pending_tasks_;
// A log of messages received by this object.
std::vector<syncer_v2::CommitResponseDataList> received_commit_responses_;
std::vector<syncer_v2::UpdateResponseDataList> received_update_responses_;
std::vector<syncer_v2::UpdateResponseDataList> received_pending_updates_;
std::vector<syncer_v2::DataTypeState> type_states_received_on_update_;
std::vector<syncer_v2::DataTypeState> type_states_received_on_commit_;
std::vector<CommitResponseDataList> received_commit_responses_;
std::vector<UpdateResponseDataList> received_update_responses_;
std::vector<UpdateResponseDataList> received_pending_updates_;
std::vector<DataTypeState> type_states_received_on_update_;
std::vector<DataTypeState> type_states_received_on_commit_;
// Latest responses received, indexed by tag_hash.
std::map<const std::string, syncer_v2::CommitResponseData>
commit_response_items_;
std::map<const std::string, syncer_v2::UpdateResponseData>
update_response_items_;
std::map<const std::string, CommitResponseData> commit_response_items_;
std::map<const std::string, UpdateResponseData> update_response_items_;
// The per-item state maps.
std::map<const std::string, int64> sequence_numbers_;

41
sync/test/engine/mock_model_type_sync_worker.cc

@ -6,7 +6,7 @@
#include "base/logging.h"
namespace syncer {
namespace syncer_v2 {
MockModelTypeSyncWorker::MockModelTypeSyncWorker() {
}
@ -15,7 +15,7 @@ MockModelTypeSyncWorker::~MockModelTypeSyncWorker() {
}
void MockModelTypeSyncWorker::EnqueueForCommit(
const syncer_v2::CommitRequestDataList& list) {
const CommitRequestDataList& list) {
commit_request_lists_.push_back(list);
}
@ -23,8 +23,8 @@ size_t MockModelTypeSyncWorker::GetNumCommitRequestLists() const {
return commit_request_lists_.size();
}
syncer_v2::CommitRequestDataList
MockModelTypeSyncWorker::GetNthCommitRequestList(size_t n) const {
CommitRequestDataList MockModelTypeSyncWorker::GetNthCommitRequestList(
size_t n) const {
DCHECK_LT(n, GetNumCommitRequestLists());
return commit_request_lists_[n];
}
@ -33,11 +33,10 @@ bool MockModelTypeSyncWorker::HasCommitRequestForTagHash(
const std::string& tag_hash) const {
// Iterate backward through the sets of commit requests to find the most
// recent one that applies to the specified tag_hash.
for (std::vector<syncer_v2::CommitRequestDataList>::const_reverse_iterator
lists_it = commit_request_lists_.rbegin();
for (std::vector<CommitRequestDataList>::const_reverse_iterator lists_it =
commit_request_lists_.rbegin();
lists_it != commit_request_lists_.rend(); ++lists_it) {
for (syncer_v2::CommitRequestDataList::const_iterator it =
lists_it->begin();
for (CommitRequestDataList::const_iterator it = lists_it->begin();
it != lists_it->end(); ++it) {
if (it->client_tag_hash == tag_hash) {
return true;
@ -48,16 +47,14 @@ bool MockModelTypeSyncWorker::HasCommitRequestForTagHash(
return false;
}
syncer_v2::CommitRequestData
MockModelTypeSyncWorker::GetLatestCommitRequestForTagHash(
CommitRequestData MockModelTypeSyncWorker::GetLatestCommitRequestForTagHash(
const std::string& tag_hash) const {
// Iterate backward through the sets of commit requests to find the most
// recent one that applies to the specified tag_hash.
for (std::vector<syncer_v2::CommitRequestDataList>::const_reverse_iterator
lists_it = commit_request_lists_.rbegin();
for (std::vector<CommitRequestDataList>::const_reverse_iterator lists_it =
commit_request_lists_.rbegin();
lists_it != commit_request_lists_.rend(); ++lists_it) {
for (syncer_v2::CommitRequestDataList::const_iterator it =
lists_it->begin();
for (CommitRequestDataList::const_iterator it = lists_it->begin();
it != lists_it->end(); ++it) {
if (it->client_tag_hash == tag_hash) {
return *it;
@ -66,10 +63,10 @@ MockModelTypeSyncWorker::GetLatestCommitRequestForTagHash(
}
NOTREACHED() << "Could not find commit for tag hash " << tag_hash << ".";
return syncer_v2::CommitRequestData();
return CommitRequestData();
}
syncer_v2::UpdateResponseData MockModelTypeSyncWorker::UpdateFromServer(
UpdateResponseData MockModelTypeSyncWorker::UpdateFromServer(
int64 version_offset,
const std::string& tag_hash,
const sync_pb::EntitySpecifics& specifics) {
@ -80,7 +77,7 @@ syncer_v2::UpdateResponseData MockModelTypeSyncWorker::UpdateFromServer(
SetServerVersion(tag_hash, version);
}
syncer_v2::UpdateResponseData data;
UpdateResponseData data;
data.id = GenerateId(tag_hash);
data.client_tag_hash = tag_hash;
data.response_version = version;
@ -98,7 +95,7 @@ syncer_v2::UpdateResponseData MockModelTypeSyncWorker::UpdateFromServer(
return data;
}
syncer_v2::UpdateResponseData MockModelTypeSyncWorker::TombstoneFromServer(
UpdateResponseData MockModelTypeSyncWorker::TombstoneFromServer(
int64 version_offset,
const std::string& tag_hash) {
int64 old_version = GetServerVersion(tag_hash);
@ -107,7 +104,7 @@ syncer_v2::UpdateResponseData MockModelTypeSyncWorker::TombstoneFromServer(
SetServerVersion(tag_hash, version);
}
syncer_v2::UpdateResponseData data;
UpdateResponseData data;
data.id = GenerateId(tag_hash);
data.client_tag_hash = tag_hash;
data.response_version = version;
@ -124,11 +121,11 @@ syncer_v2::UpdateResponseData MockModelTypeSyncWorker::TombstoneFromServer(
return data;
}
syncer_v2::CommitResponseData MockModelTypeSyncWorker::SuccessfulCommitResponse(
const syncer_v2::CommitRequestData& request_data) {
CommitResponseData MockModelTypeSyncWorker::SuccessfulCommitResponse(
const CommitRequestData& request_data) {
const std::string& client_tag_hash = request_data.client_tag_hash;
syncer_v2::CommitResponseData response_data;
CommitResponseData response_data;
if (request_data.base_version == 0) {
// Server assigns new ID to newly committed items.

21
sync/test/engine/mock_model_type_sync_worker.h

@ -11,7 +11,7 @@
#include "sync/engine/model_type_sync_worker.h"
#include "sync/internal_api/public/non_blocking_sync_common.h"
namespace syncer {
namespace syncer_v2 {
// Receives and records commit requests sent through the ModelTypeSyncWorker.
//
@ -24,13 +24,13 @@ class MockModelTypeSyncWorker : public ModelTypeSyncWorker {
~MockModelTypeSyncWorker() override;
// Implementation of ModelTypeSyncWorker.
void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override;
void EnqueueForCommit(const CommitRequestDataList& list) override;
// Getters to inspect the requests sent to this object.
size_t GetNumCommitRequestLists() const;
syncer_v2::CommitRequestDataList GetNthCommitRequestList(size_t n) const;
CommitRequestDataList GetNthCommitRequestList(size_t n) const;
bool HasCommitRequestForTagHash(const std::string& tag_hash) const;
syncer_v2::CommitRequestData GetLatestCommitRequestForTagHash(
CommitRequestData GetLatestCommitRequestForTagHash(
const std::string& tag_hash) const;
// Functions to produce state as though it came from a real server and had
@ -42,21 +42,20 @@ class MockModelTypeSyncWorker : public ModelTypeSyncWorker {
// The |version_offset| field can be used to emulate stale data (ie. versions
// going backwards), reflections and redeliveries (ie. several instances of
// the same version) or new updates.
syncer_v2::UpdateResponseData UpdateFromServer(
UpdateResponseData UpdateFromServer(
int64 version_offset,
const std::string& tag_hash,
const sync_pb::EntitySpecifics& specifics);
// Returns an UpdateResponseData representing a tombstone update from the
// server. Updates server state accordingly.
syncer_v2::UpdateResponseData TombstoneFromServer(
int64 version_offset,
const std::string& tag_hash);
UpdateResponseData TombstoneFromServer(int64 version_offset,
const std::string& tag_hash);
// Returns a commit response that indicates a successful commit of the
// given |request_data|. Updates server state accordingly.
syncer_v2::CommitResponseData SuccessfulCommitResponse(
const syncer_v2::CommitRequestData& request_data);
CommitResponseData SuccessfulCommitResponse(
const CommitRequestData& request_data);
// Sets the encryption key name used for updates from the server.
// (ie. the key other clients are using to encrypt their commits.)
@ -72,7 +71,7 @@ class MockModelTypeSyncWorker : public ModelTypeSyncWorker {
void SetServerVersion(const std::string& tag_hash, int64 version);
// A record of past commits requests.
std::vector<syncer_v2::CommitRequestDataList> commit_request_lists_;
std::vector<CommitRequestDataList> commit_request_lists_;
// Map of versions by client tag.
// This is an essential part of the mocked server state.