From 3f8556a0cf934ee6e2e4a37b22b05dbf0a9c4a90 Mon Sep 17 00:00:00 2001 From: "tim@chromium.org" Date: Thu, 7 Jun 2012 17:50:19 +0000 Subject: sync: create internal_api/public to house sync/ files needed by chrome/browser/sync. Note on sync.gyp changes and .cc file moves: most files in /public have .h and their .cc side by side, as they are simple implementations. In some cases like model_type.cc (and others in a follow up patch, like sync_manager.cc) have only their header exposed in /public while the impl stays behind, because it needs to include things from within sync/, and /public has a strict include DEPS policy. This is in accordance with other /public folders (like content/). Cleans up DEPS files in sync + c/b/sync. Adds sync/{engine, sessions, syncable} to public/. There is more to come (moving things in internal_api/ into public). Not touching /notifier as that is in flux at the moment. BUG=131130 TEST= Review URL: https://chromiumcodereview.appspot.com/10532019 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@141038 0039d316-1c4b-4281-b951-d872f2087c98 --- sync/internal_api/public/DEPS | 5 + .../public/engine/model_safe_worker.cc | 75 ++++++ .../internal_api/public/engine/model_safe_worker.h | 87 +++++++ .../public/engine/model_safe_worker_unittest.cc | 55 ++++ .../public/engine/passive_model_worker.cc | 28 ++ .../public/engine/passive_model_worker.h | 40 +++ .../public/engine/polling_constants.cc | 26 ++ .../internal_api/public/engine/polling_constants.h | 20 ++ .../internal_api/public/sessions/error_counters.cc | 17 ++ sync/internal_api/public/sessions/error_counters.h | 33 +++ .../public/sessions/sync_session_snapshot.cc | 173 +++++++++++++ .../public/sessions/sync_session_snapshot.h | 101 ++++++++ .../public/sessions/sync_source_info.cc | 36 +++ .../public/sessions/sync_source_info.h | 42 +++ sync/internal_api/public/sessions/syncer_status.cc | 44 ++++ sync/internal_api/public/sessions/syncer_status.h | 50 ++++ sync/internal_api/public/syncable/model_type.h | 175 +++++++++++++ .../public/syncable/model_type_payload_map.cc | 105 ++++++++ .../public/syncable/model_type_payload_map.h | 60 +++++ .../syncable/model_type_payload_map_unittest.cc | 46 ++++ .../public/syncable/model_type_test_util.cc | 52 ++++ .../public/syncable/model_type_test_util.h | 26 ++ sync/internal_api/public/util/enum_set.h | 286 +++++++++++++++++++++ sync/internal_api/public/util/enum_set_unittest.cc | 195 ++++++++++++++ sync/internal_api/public/util/syncer_error.cc | 36 +++ sync/internal_api/public/util/syncer_error.h | 46 ++++ 26 files changed, 1859 insertions(+) create mode 100644 sync/internal_api/public/DEPS create mode 100644 sync/internal_api/public/engine/model_safe_worker.cc create mode 100644 sync/internal_api/public/engine/model_safe_worker.h create mode 100644 sync/internal_api/public/engine/model_safe_worker_unittest.cc create mode 100644 sync/internal_api/public/engine/passive_model_worker.cc create mode 100644 sync/internal_api/public/engine/passive_model_worker.h create mode 100644 sync/internal_api/public/engine/polling_constants.cc create mode 100644 sync/internal_api/public/engine/polling_constants.h create mode 100644 sync/internal_api/public/sessions/error_counters.cc create mode 100644 sync/internal_api/public/sessions/error_counters.h create mode 100644 sync/internal_api/public/sessions/sync_session_snapshot.cc create mode 100644 sync/internal_api/public/sessions/sync_session_snapshot.h create mode 100644 sync/internal_api/public/sessions/sync_source_info.cc create mode 100644 sync/internal_api/public/sessions/sync_source_info.h create mode 100644 sync/internal_api/public/sessions/syncer_status.cc create mode 100644 sync/internal_api/public/sessions/syncer_status.h create mode 100644 sync/internal_api/public/syncable/model_type.h create mode 100644 sync/internal_api/public/syncable/model_type_payload_map.cc create mode 100644 sync/internal_api/public/syncable/model_type_payload_map.h create mode 100644 sync/internal_api/public/syncable/model_type_payload_map_unittest.cc create mode 100644 sync/internal_api/public/syncable/model_type_test_util.cc create mode 100644 sync/internal_api/public/syncable/model_type_test_util.h create mode 100644 sync/internal_api/public/util/enum_set.h create mode 100644 sync/internal_api/public/util/enum_set_unittest.cc create mode 100644 sync/internal_api/public/util/syncer_error.cc create mode 100644 sync/internal_api/public/util/syncer_error.h (limited to 'sync/internal_api/public') diff --git a/sync/internal_api/public/DEPS b/sync/internal_api/public/DEPS new file mode 100644 index 0000000..2a51ace --- /dev/null +++ b/sync/internal_api/public/DEPS @@ -0,0 +1,5 @@ +include_rules = [ + "-sync", + "+sync/internal_api/public", + "+sync/protocol", +] diff --git a/sync/internal_api/public/engine/model_safe_worker.cc b/sync/internal_api/public/engine/model_safe_worker.cc new file mode 100644 index 0000000..2718acc --- /dev/null +++ b/sync/internal_api/public/engine/model_safe_worker.cc @@ -0,0 +1,75 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/engine/model_safe_worker.h" + +#include "base/json/json_writer.h" +#include "base/memory/scoped_ptr.h" +#include "base/values.h" + +namespace browser_sync { + +base::DictionaryValue* ModelSafeRoutingInfoToValue( + const ModelSafeRoutingInfo& routing_info) { + base::DictionaryValue* dict = new base::DictionaryValue(); + for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin(); + it != routing_info.end(); ++it) { + dict->SetString(syncable::ModelTypeToString(it->first), + ModelSafeGroupToString(it->second)); + } + return dict; +} + +std::string ModelSafeRoutingInfoToString( + const ModelSafeRoutingInfo& routing_info) { + scoped_ptr dict(ModelSafeRoutingInfoToValue(routing_info)); + std::string json; + base::JSONWriter::Write(dict.get(), &json); + return json; +} + +syncable::ModelTypeSet GetRoutingInfoTypes( + const ModelSafeRoutingInfo& routing_info) { + syncable::ModelTypeSet types; + for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin(); + it != routing_info.end(); ++it) { + types.Put(it->first); + } + return types; +} + +ModelSafeGroup GetGroupForModelType(const syncable::ModelType type, + const ModelSafeRoutingInfo& routes) { + ModelSafeRoutingInfo::const_iterator it = routes.find(type); + if (it == routes.end()) { + if (type != syncable::UNSPECIFIED && type != syncable::TOP_LEVEL_FOLDER) + LOG(WARNING) << "Entry does not belong to active ModelSafeGroup!"; + return GROUP_PASSIVE; + } + return it->second; +} + +std::string ModelSafeGroupToString(ModelSafeGroup group) { + switch (group) { + case GROUP_UI: + return "GROUP_UI"; + case GROUP_DB: + return "GROUP_DB"; + case GROUP_FILE: + return "GROUP_FILE"; + case GROUP_HISTORY: + return "GROUP_HISTORY"; + case GROUP_PASSIVE: + return "GROUP_PASSIVE"; + case GROUP_PASSWORD: + return "GROUP_PASSWORD"; + default: + NOTREACHED(); + return "INVALID"; + } +} + +ModelSafeWorker::~ModelSafeWorker() {} + +} // namespace browser_sync diff --git a/sync/internal_api/public/engine/model_safe_worker.h b/sync/internal_api/public/engine/model_safe_worker.h new file mode 100644 index 0000000..1a6c371 --- /dev/null +++ b/sync/internal_api/public/engine/model_safe_worker.h @@ -0,0 +1,87 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_ +#define SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_ +#pragma once + +#include +#include +#include + +#include "base/callback.h" +#include "base/memory/ref_counted.h" +#include "sync/internal_api/public/syncable/model_type.h" +#include "sync/internal_api/public/util/syncer_error.h" + +namespace base { +class DictionaryValue; +} // namespace + +namespace browser_sync { + +typedef base::Callback WorkCallback; + +enum ModelSafeGroup { + GROUP_PASSIVE = 0, // Models that are just "passively" being synced; e.g. + // changes to these models don't need to be pushed to a + // native model. + GROUP_UI, // Models that live on UI thread and are being synced. + GROUP_DB, // Models that live on DB thread and are being synced. + GROUP_FILE, // Models that live on FILE thread and are being synced. + GROUP_HISTORY, // Models that live on history thread and are being + // synced. + GROUP_PASSWORD, // Models that live on the password thread and are + // being synced. On windows and linux, this runs on the + // DB thread. + MODEL_SAFE_GROUP_COUNT, +}; + +std::string ModelSafeGroupToString(ModelSafeGroup group); + +// The Syncer uses a ModelSafeWorker for all tasks that could potentially +// modify syncable entries (e.g under a WriteTransaction). The ModelSafeWorker +// only knows how to do one thing, and that is take some work (in a fully +// pre-bound callback) and have it performed (as in Run()) from a thread which +// is guaranteed to be "model-safe", where "safe" refers to not allowing us to +// cause an embedding application model to fall out of sync with the +// syncable::Directory due to a race. +class ModelSafeWorker : public base::RefCountedThreadSafe { + public: + // Any time the Syncer performs model modifications (e.g employing a + // WriteTransaction), it should be done by this method to ensure it is done + // from a model-safe thread. + virtual SyncerError DoWorkAndWaitUntilDone(const WorkCallback& work) = 0; + + virtual ModelSafeGroup GetModelSafeGroup() = 0; + + protected: + virtual ~ModelSafeWorker(); + + private: + friend class base::RefCountedThreadSafe; +}; + +// A map that details which ModelSafeGroup each syncable::ModelType +// belongs to. Routing info can change in response to the user enabling / +// disabling sync for certain types, as well as model association completions. +typedef std::map + ModelSafeRoutingInfo; + +// Caller takes ownership of return value. +base::DictionaryValue* ModelSafeRoutingInfoToValue( + const ModelSafeRoutingInfo& routing_info); + +std::string ModelSafeRoutingInfoToString( + const ModelSafeRoutingInfo& routing_info); + +syncable::ModelTypeSet GetRoutingInfoTypes( + const ModelSafeRoutingInfo& routing_info); + +ModelSafeGroup GetGroupForModelType(const syncable::ModelType type, + const ModelSafeRoutingInfo& routes); + +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_ENGINE_MODEL_SAFE_WORKER_H_ diff --git a/sync/internal_api/public/engine/model_safe_worker_unittest.cc b/sync/internal_api/public/engine/model_safe_worker_unittest.cc new file mode 100644 index 0000000..5304c13 --- /dev/null +++ b/sync/internal_api/public/engine/model_safe_worker_unittest.cc @@ -0,0 +1,55 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/engine/model_safe_worker.h" + +#include "base/memory/scoped_ptr.h" +#include "base/values.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace browser_sync { +namespace { + +class ModelSafeWorkerTest : public ::testing::Test { +}; + +TEST_F(ModelSafeWorkerTest, ModelSafeRoutingInfoToValue) { + ModelSafeRoutingInfo routing_info; + routing_info[syncable::BOOKMARKS] = GROUP_PASSIVE; + routing_info[syncable::NIGORI] = GROUP_UI; + routing_info[syncable::PREFERENCES] = GROUP_DB; + DictionaryValue expected_value; + expected_value.SetString("Bookmarks", "GROUP_PASSIVE"); + expected_value.SetString("Encryption keys", "GROUP_UI"); + expected_value.SetString("Preferences", "GROUP_DB"); + scoped_ptr value( + ModelSafeRoutingInfoToValue(routing_info)); + EXPECT_TRUE(value->Equals(&expected_value)); +} + +TEST_F(ModelSafeWorkerTest, ModelSafeRoutingInfoToString) { + ModelSafeRoutingInfo routing_info; + routing_info[syncable::BOOKMARKS] = GROUP_PASSIVE; + routing_info[syncable::NIGORI] = GROUP_UI; + routing_info[syncable::PREFERENCES] = GROUP_DB; + EXPECT_EQ( + "{\"Bookmarks\":\"GROUP_PASSIVE\",\"Encryption keys\":\"GROUP_UI\"," + "\"Preferences\":\"GROUP_DB\"}", + ModelSafeRoutingInfoToString(routing_info)); +} + +TEST_F(ModelSafeWorkerTest, GetRoutingInfoTypes) { + ModelSafeRoutingInfo routing_info; + routing_info[syncable::BOOKMARKS] = GROUP_PASSIVE; + routing_info[syncable::NIGORI] = GROUP_UI; + routing_info[syncable::PREFERENCES] = GROUP_DB; + const syncable::ModelTypeSet expected_types( + syncable::BOOKMARKS, + syncable::NIGORI, + syncable::PREFERENCES); + EXPECT_TRUE(GetRoutingInfoTypes(routing_info).Equals(expected_types)); +} + +} // namespace +} // namespace browser_sync diff --git a/sync/internal_api/public/engine/passive_model_worker.cc b/sync/internal_api/public/engine/passive_model_worker.cc new file mode 100644 index 0000000..26fccc1 --- /dev/null +++ b/sync/internal_api/public/engine/passive_model_worker.cc @@ -0,0 +1,28 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/engine/passive_model_worker.h" + +#include "base/message_loop.h" + +namespace browser_sync { + +PassiveModelWorker::PassiveModelWorker(const MessageLoop* sync_loop) + : sync_loop_(sync_loop) {} + +PassiveModelWorker::~PassiveModelWorker() { +} + +SyncerError PassiveModelWorker::DoWorkAndWaitUntilDone( + const WorkCallback& work) { + DCHECK_EQ(MessageLoop::current(), sync_loop_); + // Simply do the work on the current thread. + return work.Run(); +} + +ModelSafeGroup PassiveModelWorker::GetModelSafeGroup() { + return GROUP_PASSIVE; +} + +} // namespace browser_sync diff --git a/sync/internal_api/public/engine/passive_model_worker.h b/sync/internal_api/public/engine/passive_model_worker.h new file mode 100644 index 0000000..7c0ddf3 --- /dev/null +++ b/sync/internal_api/public/engine/passive_model_worker.h @@ -0,0 +1,40 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_ENGINE_PASSIVE_MODEL_WORKER_H_ +#define SYNC_INTERNAL_API_PUBLIC_ENGINE_PASSIVE_MODEL_WORKER_H_ +#pragma once + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "sync/internal_api/public/engine/model_safe_worker.h" +#include "sync/internal_api/public/util/syncer_error.h" + +class MessageLoop; + +namespace browser_sync { + +// Implementation of ModelSafeWorker for passive types. All work is +// done on the same thread DoWorkAndWaitUntilDone (i.e., the sync +// thread). +class PassiveModelWorker : public ModelSafeWorker { + public: + explicit PassiveModelWorker(const MessageLoop* sync_loop); + + // ModelSafeWorker implementation. Called on the sync thread. + virtual SyncerError DoWorkAndWaitUntilDone( + const WorkCallback& work) OVERRIDE; + virtual ModelSafeGroup GetModelSafeGroup() OVERRIDE; + + private: + virtual ~PassiveModelWorker(); + + const MessageLoop* const sync_loop_; + + DISALLOW_COPY_AND_ASSIGN(PassiveModelWorker); +}; + +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_ENGINE_PASSIVE_MODEL_WORKER_H_ diff --git a/sync/internal_api/public/engine/polling_constants.cc b/sync/internal_api/public/engine/polling_constants.cc new file mode 100644 index 0000000..d7fe753 --- /dev/null +++ b/sync/internal_api/public/engine/polling_constants.cc @@ -0,0 +1,26 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "base/basictypes.h" +#include "sync/internal_api/public/engine/polling_constants.h" + +namespace browser_sync { + +// Server can overwrite these values via client commands. +// Standard short poll. This is used when XMPP is off. +// We use high values here to ensure that failure to receive poll updates from +// the server doesn't result in rapid-fire polling from the client due to low +// local limits. +const int64 kDefaultShortPollIntervalSeconds = 3600 * 8; +// Long poll is used when XMPP is on. +const int64 kDefaultLongPollIntervalSeconds = 3600 * 12; + +// Maximum interval for exponential backoff. +const int64 kMaxBackoffSeconds = 60 * 60 * 4; // 4 hours. + +// Backoff interval randomization factor. +const int kBackoffRandomizationFactor = 2; + +} // namespace browser_sync + diff --git a/sync/internal_api/public/engine/polling_constants.h b/sync/internal_api/public/engine/polling_constants.h new file mode 100644 index 0000000..9adfe92 --- /dev/null +++ b/sync/internal_api/public/engine/polling_constants.h @@ -0,0 +1,20 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Constants used by SyncScheduler when polling servers for updates. + +#ifndef SYNC_INTERNAL_API_PUBLIC_ENGINE_POLLING_CONSTANTS_H_ +#define SYNC_INTERNAL_API_PUBLIC_ENGINE_POLLING_CONSTANTS_H_ +#pragma once + +namespace browser_sync { + +extern const int64 kDefaultShortPollIntervalSeconds; +extern const int64 kDefaultLongPollIntervalSeconds; +extern const int64 kMaxBackoffSeconds; +extern const int kBackoffRandomizationFactor; + +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_ENGINE_POLLING_CONSTANTS_H_ diff --git a/sync/internal_api/public/sessions/error_counters.cc b/sync/internal_api/public/sessions/error_counters.cc new file mode 100644 index 0000000..72ed2d1 --- /dev/null +++ b/sync/internal_api/public/sessions/error_counters.cc @@ -0,0 +1,17 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/sessions/error_counters.h" + +namespace browser_sync { +namespace sessions { + +ErrorCounters::ErrorCounters() + : last_download_updates_result(UNSET), + last_post_commit_result(UNSET), + last_process_commit_response_result(UNSET) { +} + +} // namespace sessions +} // namespace browser_sync diff --git a/sync/internal_api/public/sessions/error_counters.h b/sync/internal_api/public/sessions/error_counters.h new file mode 100644 index 0000000..a2f528c --- /dev/null +++ b/sync/internal_api/public/sessions/error_counters.h @@ -0,0 +1,33 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_SESSIONS_ERROR_COUNTERS_H_ +#define SYNC_INTERNAL_API_PUBLIC_SESSIONS_ERROR_COUNTERS_H_ +#pragma once + +#include "base/basictypes.h" +#include "sync/internal_api/public/util/syncer_error.h" +#include "sync/protocol/sync_protocol_error.h" + +namespace browser_sync { +namespace sessions { + +// Counters for various errors that can occur repeatedly during a sync session. +// TODO(lipalani) : Rename this structure to Error. +struct ErrorCounters { + ErrorCounters(); + + // Any protocol errors that we received during this sync session. + SyncProtocolError sync_protocol_error; + + // Records the most recent results of PostCommit and GetUpdates commands. + SyncerError last_download_updates_result; + SyncerError last_post_commit_result; + SyncerError last_process_commit_response_result; +}; + +} // namespace sessions +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_SESSIONS_ERROR_COUNTERS_H_ diff --git a/sync/internal_api/public/sessions/sync_session_snapshot.cc b/sync/internal_api/public/sessions/sync_session_snapshot.cc new file mode 100644 index 0000000..d058a4f --- /dev/null +++ b/sync/internal_api/public/sessions/sync_session_snapshot.cc @@ -0,0 +1,173 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/sessions/sync_session_snapshot.h" + +#include "base/json/json_writer.h" +#include "base/values.h" + +namespace browser_sync { +namespace sessions { + +SyncSessionSnapshot::SyncSessionSnapshot() + : num_server_changes_remaining_(0), + is_share_usable_(false), + has_more_to_sync_(false), + is_silenced_(false), + num_encryption_conflicts_(0), + num_hierarchy_conflicts_(0), + num_simple_conflicts_(0), + num_server_conflicts_(0), + notifications_enabled_(false), + num_entries_(0), + retry_scheduled_(false) { +} + +SyncSessionSnapshot::SyncSessionSnapshot( + const SyncerStatus& syncer_status, + const ErrorCounters& errors, + int64 num_server_changes_remaining, + bool is_share_usable, + syncable::ModelTypeSet initial_sync_ended, + const syncable::ModelTypePayloadMap& download_progress_markers, + bool more_to_sync, + bool is_silenced, + int num_encryption_conflicts, + int num_hierarchy_conflicts, + int num_simple_conflicts, + int num_server_conflicts, + const SyncSourceInfo& source, + bool notifications_enabled, + size_t num_entries, + base::Time sync_start_time, + bool retry_scheduled) + : syncer_status_(syncer_status), + errors_(errors), + num_server_changes_remaining_(num_server_changes_remaining), + is_share_usable_(is_share_usable), + initial_sync_ended_(initial_sync_ended), + download_progress_markers_(download_progress_markers), + has_more_to_sync_(more_to_sync), + is_silenced_(is_silenced), + num_encryption_conflicts_(num_encryption_conflicts), + num_hierarchy_conflicts_(num_hierarchy_conflicts), + num_simple_conflicts_(num_simple_conflicts), + num_server_conflicts_(num_server_conflicts), + source_(source), + notifications_enabled_(notifications_enabled), + num_entries_(num_entries), + sync_start_time_(sync_start_time), + retry_scheduled_(retry_scheduled) { +} + +SyncSessionSnapshot::~SyncSessionSnapshot() {} + +DictionaryValue* SyncSessionSnapshot::ToValue() const { + DictionaryValue* value = new DictionaryValue(); + value->Set("syncerStatus", syncer_status_.ToValue()); + // We don't care too much if we lose precision here. + value->SetInteger("numServerChangesRemaining", + static_cast(num_server_changes_remaining_)); + value->SetBoolean("isShareUsable", is_share_usable_); + value->Set("initialSyncEnded", + syncable::ModelTypeSetToValue(initial_sync_ended_)); + value->Set("downloadProgressMarkers", + syncable::ModelTypePayloadMapToValue(download_progress_markers_)); + value->SetBoolean("hasMoreToSync", has_more_to_sync_); + value->SetBoolean("isSilenced", is_silenced_); + // We don't care too much if we lose precision here, also. + value->SetInteger("numEncryptionConflicts", + num_encryption_conflicts_); + value->SetInteger("numHierarchyConflicts", + num_hierarchy_conflicts_); + value->SetInteger("numSimpleConflicts", + num_simple_conflicts_); + value->SetInteger("numServerConflicts", + num_server_conflicts_); + value->SetInteger("numEntries", num_entries_); + value->Set("source", source_.ToValue()); + value->SetBoolean("notificationsEnabled", notifications_enabled_); + return value; +} + +std::string SyncSessionSnapshot::ToString() const { + scoped_ptr value(ToValue()); + std::string json; + base::JSONWriter::WriteWithOptions(value.get(), + base::JSONWriter::OPTIONS_PRETTY_PRINT, + &json); + return json; +} + +SyncerStatus SyncSessionSnapshot::syncer_status() const { + return syncer_status_; +} + +ErrorCounters SyncSessionSnapshot::errors() const { + return errors_; +} + +int64 SyncSessionSnapshot::num_server_changes_remaining() const { + return num_server_changes_remaining_; +} + +bool SyncSessionSnapshot::is_share_usable() const { + return is_share_usable_; +} + +syncable::ModelTypeSet SyncSessionSnapshot::initial_sync_ended() const { + return initial_sync_ended_; +} + +syncable::ModelTypePayloadMap + SyncSessionSnapshot::download_progress_markers() const { + return download_progress_markers_; +} + +bool SyncSessionSnapshot::has_more_to_sync() const { + return has_more_to_sync_; +} + +bool SyncSessionSnapshot::is_silenced() const { + return is_silenced_; +} + +int SyncSessionSnapshot::num_encryption_conflicts() const { + return num_encryption_conflicts_; +} + +int SyncSessionSnapshot::num_hierarchy_conflicts() const { + return num_hierarchy_conflicts_; +} + +int SyncSessionSnapshot::num_simple_conflicts() const { + return num_simple_conflicts_; +} + +int SyncSessionSnapshot::num_server_conflicts() const { + return num_server_conflicts_; +} + +SyncSourceInfo SyncSessionSnapshot::source() const { + return source_; +} + +bool SyncSessionSnapshot::notifications_enabled() const { + return notifications_enabled_; +} + +size_t SyncSessionSnapshot::num_entries() const { + return num_entries_; +} + +base::Time SyncSessionSnapshot::sync_start_time() const { + return sync_start_time_; +} + +bool SyncSessionSnapshot::retry_scheduled() const { + return retry_scheduled_; +} + +} // namespace sessions +} // namespace browser_sync diff --git a/sync/internal_api/public/sessions/sync_session_snapshot.h b/sync/internal_api/public/sessions/sync_session_snapshot.h new file mode 100644 index 0000000..9ed9465 --- /dev/null +++ b/sync/internal_api/public/sessions/sync_session_snapshot.h @@ -0,0 +1,101 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SESSION_SNAPSHOT_H_ +#define SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SESSION_SNAPSHOT_H_ +#pragma once + +#include + +#include "base/basictypes.h" +#include "base/time.h" +#include "sync/internal_api/public/sessions/error_counters.h" +#include "sync/internal_api/public/sessions/sync_source_info.h" +#include "sync/internal_api/public/sessions/syncer_status.h" +#include "sync/internal_api/public/syncable/model_type.h" +#include "sync/internal_api/public/syncable/model_type_payload_map.h" + +namespace base { +class DictionaryValue; +} + +namespace browser_sync { +namespace sessions { + +// An immutable snapshot of state from a SyncSession. Convenient to use as +// part of notifications as it is inherently thread-safe. +// TODO(zea): if copying this all over the place starts getting expensive, +// consider passing around immutable references instead of values. +// Default copy and assign welcome. +class SyncSessionSnapshot { + public: + SyncSessionSnapshot(); + SyncSessionSnapshot( + const SyncerStatus& syncer_status, + const ErrorCounters& errors, + int64 num_server_changes_remaining, + bool is_share_usable, + syncable::ModelTypeSet initial_sync_ended, + const syncable::ModelTypePayloadMap& download_progress_markers, + bool more_to_sync, + bool is_silenced, + int num_encryption_conflicts, + int num_hierarchy_conflicts, + int num_simple_conflicts, + int num_server_conflicts, + const SyncSourceInfo& source, + bool notifications_enabled, + size_t num_entries, + base::Time sync_start_time, + bool retry_scheduled); + ~SyncSessionSnapshot(); + + // Caller takes ownership of the returned dictionary. + base::DictionaryValue* ToValue() const; + + std::string ToString() const; + + SyncerStatus syncer_status() const; + ErrorCounters errors() const; + int64 num_server_changes_remaining() const; + bool is_share_usable() const; + syncable::ModelTypeSet initial_sync_ended() const; + syncable::ModelTypePayloadMap download_progress_markers() const; + bool has_more_to_sync() const; + bool is_silenced() const; + int num_encryption_conflicts() const; + int num_hierarchy_conflicts() const; + int num_simple_conflicts() const; + int num_server_conflicts() const; + bool did_commit_items() const; + SyncSourceInfo source() const; + bool notifications_enabled() const; + size_t num_entries() const; + base::Time sync_start_time() const; + bool retry_scheduled() const; + + private: + SyncerStatus syncer_status_; + ErrorCounters errors_; + int64 num_server_changes_remaining_; + bool is_share_usable_; + syncable::ModelTypeSet initial_sync_ended_; + syncable::ModelTypePayloadMap download_progress_markers_; + bool has_more_to_sync_; + bool is_silenced_; + int num_encryption_conflicts_; + int num_hierarchy_conflicts_; + int num_simple_conflicts_; + int num_server_conflicts_; + SyncSourceInfo source_; + bool notifications_enabled_; + size_t num_entries_; + base::Time sync_start_time_; + bool retry_scheduled_; +}; + +} // namespace sessions +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SESSION_SNAPSHOT_H_ diff --git a/sync/internal_api/public/sessions/sync_source_info.cc b/sync/internal_api/public/sessions/sync_source_info.cc new file mode 100644 index 0000000..191199b --- /dev/null +++ b/sync/internal_api/public/sessions/sync_source_info.cc @@ -0,0 +1,36 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/sessions/sync_source_info.h" + +#include "base/values.h" +#include "sync/protocol/proto_enum_conversions.h" + +namespace browser_sync { +namespace sessions { + +SyncSourceInfo::SyncSourceInfo() + : updates_source(sync_pb::GetUpdatesCallerInfo::UNKNOWN) {} + +SyncSourceInfo::SyncSourceInfo( + const syncable::ModelTypePayloadMap& t) + : updates_source(sync_pb::GetUpdatesCallerInfo::UNKNOWN), types(t) {} + +SyncSourceInfo::SyncSourceInfo( + const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& u, + const syncable::ModelTypePayloadMap& t) + : updates_source(u), types(t) {} + +SyncSourceInfo::~SyncSourceInfo() {} + +DictionaryValue* SyncSourceInfo::ToValue() const { + DictionaryValue* value = new DictionaryValue(); + value->SetString("updatesSource", + GetUpdatesSourceString(updates_source)); + value->Set("types", syncable::ModelTypePayloadMapToValue(types)); + return value; +} + +} // namespace sessions +} // namespace browser_sync diff --git a/sync/internal_api/public/sessions/sync_source_info.h b/sync/internal_api/public/sessions/sync_source_info.h new file mode 100644 index 0000000..838e094 --- /dev/null +++ b/sync/internal_api/public/sessions/sync_source_info.h @@ -0,0 +1,42 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SOURCE_INFO_H_ +#define SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SOURCE_INFO_H_ +#pragma once + +#include "base/basictypes.h" +#include "sync/internal_api/public/syncable/model_type.h" +#include "sync/internal_api/public/syncable/model_type_payload_map.h" +#include "sync/protocol/sync.pb.h" + +namespace base { +class DictionaryValue; +} + +namespace browser_sync { +namespace sessions { + +// A container for the source of a sync session. This includes the update +// source, the datatypes triggering the sync session, and possible session +// specific payloads which should be sent to the server. +struct SyncSourceInfo { + SyncSourceInfo(); + explicit SyncSourceInfo(const syncable::ModelTypePayloadMap& t); + SyncSourceInfo( + const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& u, + const syncable::ModelTypePayloadMap& t); + ~SyncSourceInfo(); + + // Caller takes ownership of the returned dictionary. + base::DictionaryValue* ToValue() const; + + sync_pb::GetUpdatesCallerInfo::GetUpdatesSource updates_source; + syncable::ModelTypePayloadMap types; +}; + +} // namespace sessions +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNC_SOURCE_INFO_H_ diff --git a/sync/internal_api/public/sessions/syncer_status.cc b/sync/internal_api/public/sessions/syncer_status.cc new file mode 100644 index 0000000..efa0c43 --- /dev/null +++ b/sync/internal_api/public/sessions/syncer_status.cc @@ -0,0 +1,44 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/sessions/syncer_status.h" + +#include "base/values.h" + +namespace browser_sync { +namespace sessions { + +SyncerStatus::SyncerStatus() + : invalid_store(false), + num_successful_commits(0), + num_successful_bookmark_commits(0), + num_updates_downloaded_total(0), + num_tombstone_updates_downloaded_total(0), + num_reflected_updates_downloaded_total(0), + num_local_overwrites(0), + num_server_overwrites(0) { +} + +SyncerStatus::~SyncerStatus() { +} + +DictionaryValue* SyncerStatus::ToValue() const { + DictionaryValue* value = new DictionaryValue(); + value->SetBoolean("invalidStore", invalid_store); + value->SetInteger("numSuccessfulCommits", num_successful_commits); + value->SetInteger("numSuccessfulBookmarkCommits", + num_successful_bookmark_commits); + value->SetInteger("numUpdatesDownloadedTotal", + num_updates_downloaded_total); + value->SetInteger("numTombstoneUpdatesDownloadedTotal", + num_tombstone_updates_downloaded_total); + value->SetInteger("numReflectedUpdatesDownloadedTotal", + num_reflected_updates_downloaded_total); + value->SetInteger("numLocalOverwrites", num_local_overwrites); + value->SetInteger("numServerOverwrites", num_server_overwrites); + return value; +} + +} // namespace sessions +} // namespace browser_sync diff --git a/sync/internal_api/public/sessions/syncer_status.h b/sync/internal_api/public/sessions/syncer_status.h new file mode 100644 index 0000000..7331ca3 --- /dev/null +++ b/sync/internal_api/public/sessions/syncer_status.h @@ -0,0 +1,50 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNCER_STATUS_H_ +#define SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNCER_STATUS_H_ +#pragma once + +#include "base/basictypes.h" +#include "sync/internal_api/public/syncable/model_type.h" + +namespace base { +class DictionaryValue; +} + +namespace browser_sync { +namespace sessions { + +// Data pertaining to the status of an active Syncer object. +struct SyncerStatus { + SyncerStatus(); + ~SyncerStatus(); + + // Caller takes ownership of the returned dictionary. + base::DictionaryValue* ToValue() const; + + // True when we get such an INVALID_STORE error from the server. + bool invalid_store; + int num_successful_commits; + // This is needed for monitoring extensions activity. + int num_successful_bookmark_commits; + + // Download event counters. + int num_updates_downloaded_total; + int num_tombstone_updates_downloaded_total; + int num_reflected_updates_downloaded_total; + + // If the syncer encountered a MIGRATION_DONE code, these are the types that + // the client must now "migrate", by purging and re-downloading all updates. + syncable::ModelTypeSet types_needing_local_migration; + + // Overwrites due to conflict resolution counters. + int num_local_overwrites; + int num_server_overwrites; +}; + +} // namespace sessions +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_SESSIONS_SYNCER_STATUS_H_ diff --git a/sync/internal_api/public/syncable/model_type.h b/sync/internal_api/public/syncable/model_type.h new file mode 100644 index 0000000..b7b5fe3 --- /dev/null +++ b/sync/internal_api/public/syncable/model_type.h @@ -0,0 +1,175 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Enumerate the various item subtypes that are supported by sync. +// Each sync object is expected to have an immutable object type. +// An object's type is inferred from the type of data it holds. + +#ifndef SYNC_INTERNAL_API_PUBLIC_SYNCABLE_MODEL_TYPE_H_ +#define SYNC_INTERNAL_API_PUBLIC_SYNCABLE_MODEL_TYPE_H_ +#pragma once + +#include +#include + +#include "base/logging.h" +#include "base/time.h" +#include "sync/internal_api/public/util/enum_set.h" + +namespace base { +class ListValue; +class StringValue; +class Value; +} + +namespace sync_pb { +class EntitySpecifics; +class SyncEntity; +} + +namespace syncable { + +enum ModelType { + // Object type unknown. Objects may transition through + // the unknown state during their initial creation, before + // their properties are set. After deletion, object types + // are generally preserved. + UNSPECIFIED, + // A permanent folder whose children may be of mixed + // datatypes (e.g. the "Google Chrome" folder). + TOP_LEVEL_FOLDER, + + // ------------------------------------ Start of "real" model types. + // The model types declared before here are somewhat special, as they + // they do not correspond to any browser data model. The remaining types + // are bona fide model types; all have a related browser data model and + // can be represented in the protocol using a specific Message type in the + // EntitySpecifics protocol buffer. + // + // A bookmark folder or a bookmark URL object. + BOOKMARKS, + FIRST_REAL_MODEL_TYPE = BOOKMARKS, // Declared 2nd, for debugger prettiness. + + // A preference folder or a preference object. + PREFERENCES, + // A password folder or password object. + PASSWORDS, + // An AutofillProfile Object + AUTOFILL_PROFILE, + // An autofill folder or an autofill object. + AUTOFILL, + + // A themes folder or a themes object. + THEMES, + // A typed_url folder or a typed_url object. + TYPED_URLS, + // An extension folder or an extension object. + EXTENSIONS, + // An object representing a set of Nigori keys. + NIGORI, + // An object representing a custom search engine. + SEARCH_ENGINES, + // An object representing a browser session. + SESSIONS, + // An app folder or an app object. + APPS, + // An app setting from the extension settings API. + APP_SETTINGS, + // An extension setting from the extension settings API. + EXTENSION_SETTINGS, + // App notifications. + APP_NOTIFICATIONS, + LAST_REAL_MODEL_TYPE = APP_NOTIFICATIONS, + + // If you are adding a new sync datatype that is exposed to the user via the + // sync preferences UI, be sure to update the list in + // chrome/browser/sync/user_selectable_sync_type.h so that the UMA histograms + // for sync include your new type. + + MODEL_TYPE_COUNT, +}; + +typedef browser_sync::EnumSet< + ModelType, FIRST_REAL_MODEL_TYPE, LAST_REAL_MODEL_TYPE> ModelTypeSet; +typedef browser_sync::EnumSet< + ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE> FullModelTypeSet; + +inline ModelType ModelTypeFromInt(int i) { + DCHECK_GE(i, 0); + DCHECK_LT(i, MODEL_TYPE_COUNT); + return static_cast(i); +} + +void AddDefaultFieldValue(syncable::ModelType datatype, + sync_pb::EntitySpecifics* specifics); + +// Extract the model type of a SyncEntity protocol buffer. ModelType is a +// local concept: the enum is not in the protocol. The SyncEntity's ModelType +// is inferred from the presence of particular datatype field in the +// entity specifics. +ModelType GetModelType(const sync_pb::SyncEntity& sync_entity); + +// Extract the model type from an EntitySpecifics field. Note that there +// are some ModelTypes (like TOP_LEVEL_FOLDER) that can't be inferred this way; +// prefer using GetModelType where possible. +ModelType GetModelTypeFromSpecifics(const sync_pb::EntitySpecifics& specifics); + +// If this returns false, we shouldn't bother maintaining a position +// value (sibling ordering) for this item. +bool ShouldMaintainPosition(ModelType model_type); + +// Determine a model type from the field number of its associated +// EntitySpecifics field. +ModelType GetModelTypeFromSpecificsFieldNumber(int field_number); + +// Return the field number of the EntitySpecifics field associated with +// a model type. +int GetSpecificsFieldNumberFromModelType(ModelType model_type); + +// TODO(sync): The functions below badly need some cleanup. + +// Returns a pointer to a string with application lifetime that represents +// the name of |model_type|. +const char* ModelTypeToString(ModelType model_type); + +// Handles all model types, and not just real ones. +// +// Caller takes ownership of returned value. +base::StringValue* ModelTypeToValue(ModelType model_type); + +// Converts a Value into a ModelType - complement to ModelTypeToValue(). +ModelType ModelTypeFromValue(const base::Value& value); + +// Returns the ModelType corresponding to the name |model_type_string|. +ModelType ModelTypeFromString(const std::string& model_type_string); + +std::string ModelTypeSetToString(ModelTypeSet model_types); + +// Caller takes ownership of returned list. +base::ListValue* ModelTypeSetToValue(ModelTypeSet model_types); + +ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value); + +// Returns a string corresponding to the syncable tag for this datatype. +std::string ModelTypeToRootTag(ModelType type); + +// Convert a real model type to a notification type (used for +// subscribing to server-issued notifications). Returns true iff +// |model_type| was a real model type and |notification_type| was +// filled in. +bool RealModelTypeToNotificationType(ModelType model_type, + std::string* notification_type); + +// Converts a notification type to a real model type. Returns true +// iff |notification_type| was the notification type of a real model +// type and |model_type| was filled in. +bool NotificationTypeToRealModelType(const std::string& notification_type, + ModelType* model_type); + +// Returns true if |model_type| is a real datatype +bool IsRealDataType(ModelType model_type); + +} // namespace syncable + +#endif // SYNC_INTERNAL_API_PUBLIC_SYNCABLE_MODEL_TYPE_H_ diff --git a/sync/internal_api/public/syncable/model_type_payload_map.cc b/sync/internal_api/public/syncable/model_type_payload_map.cc new file mode 100644 index 0000000..cff4c92 --- /dev/null +++ b/sync/internal_api/public/syncable/model_type_payload_map.cc @@ -0,0 +1,105 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/syncable/model_type_payload_map.h" + +#include + +#include "base/base64.h" +#include "base/json/json_writer.h" +#include "base/memory/scoped_ptr.h" +#include "base/values.h" + +using browser_sync::ModelSafeRoutingInfo; +namespace syncable { + +ModelTypePayloadMap ModelTypePayloadMapFromEnumSet( + syncable::ModelTypeSet types, + const std::string& payload) { + ModelTypePayloadMap types_with_payloads; + for (syncable::ModelTypeSet::Iterator it = types.First(); + it.Good(); it.Inc()) { + types_with_payloads[it.Get()] = payload; + } + return types_with_payloads; +} + +ModelTypeSet ModelTypePayloadMapToEnumSet( + const ModelTypePayloadMap& payload_map) { + ModelTypeSet types; + for (ModelTypePayloadMap::const_iterator it = payload_map.begin(); + it != payload_map.end(); ++it) { + types.Put(it->first); + } + return types; +} + +ModelTypePayloadMap ModelTypePayloadMapFromRoutingInfo( + const browser_sync::ModelSafeRoutingInfo& routes, + const std::string& payload) { + ModelTypePayloadMap types_with_payloads; + for (browser_sync::ModelSafeRoutingInfo::const_iterator i = routes.begin(); + i != routes.end(); ++i) { + types_with_payloads[i->first] = payload; + } + return types_with_payloads; +} + +std::string ModelTypePayloadMapToString( + const ModelTypePayloadMap& type_payloads) { + scoped_ptr value( + ModelTypePayloadMapToValue(type_payloads)); + std::string json; + base::JSONWriter::Write(value.get(), &json); + return json; +} + +DictionaryValue* ModelTypePayloadMapToValue( + const ModelTypePayloadMap& type_payloads) { + DictionaryValue* value = new DictionaryValue(); + for (ModelTypePayloadMap::const_iterator it = type_payloads.begin(); + it != type_payloads.end(); ++it) { + // TODO(akalin): Unpack the value into a protobuf. + std::string base64_marker; + bool encoded = base::Base64Encode(it->second, &base64_marker); + DCHECK(encoded); + value->SetString(syncable::ModelTypeToString(it->first), base64_marker); + } + return value; +} + +void CoalescePayloads(ModelTypePayloadMap* original, + const ModelTypePayloadMap& update) { + for (ModelTypePayloadMap::const_iterator i = update.begin(); + i != update.end(); ++i) { + if (original->count(i->first) == 0) { + // If this datatype isn't already in our map, add it with + // whatever payload it has. + (*original)[i->first] = i->second; + } else if (i->second.length() > 0) { + // If this datatype is already in our map, we only overwrite the + // payload if the new one is non-empty. + (*original)[i->first] = i->second; + } + } +} + +void PurgeStalePayload(ModelTypePayloadMap* original, + const ModelSafeRoutingInfo& routing_info) { + std::vector iterators_to_delete; + for (ModelTypePayloadMap::iterator i = original->begin(); + i != original->end(); ++i) { + if (routing_info.end() == routing_info.find(i->first)) { + iterators_to_delete.push_back(i); + } + } + + for (std::vector::iterator + it = iterators_to_delete.begin(); it != iterators_to_delete.end(); + ++it) { + original->erase(*it); + } +} + +} // namespace syncable diff --git a/sync/internal_api/public/syncable/model_type_payload_map.h b/sync/internal_api/public/syncable/model_type_payload_map.h new file mode 100644 index 0000000..1bf3884 --- /dev/null +++ b/sync/internal_api/public/syncable/model_type_payload_map.h @@ -0,0 +1,60 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Definition of ModelTypePayloadMap and various utility functions. + +#ifndef SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_PAYLOAD_MAP_H_ +#define SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_PAYLOAD_MAP_H_ +#pragma once + +#include +#include + +#include "sync/internal_api/public/engine/model_safe_worker.h" +#include "sync/internal_api/public/syncable/model_type.h" + +namespace base { +class DictionaryValue; +} + +namespace syncable { + +// A container that contains a set of datatypes with possible string +// payloads. +typedef std::map ModelTypePayloadMap; + +// Helper functions for building ModelTypePayloadMaps. + +// Make a TypePayloadMap from all the types in a ModelTypeSet using a +// default payload. +ModelTypePayloadMap ModelTypePayloadMapFromEnumSet( + ModelTypeSet model_types, const std::string& payload); + +ModelTypeSet ModelTypePayloadMapToEnumSet( + const ModelTypePayloadMap& payload_map); + +// Make a TypePayloadMap for all the enabled types in a +// ModelSafeRoutingInfo using a default payload. +ModelTypePayloadMap ModelTypePayloadMapFromRoutingInfo( + const browser_sync::ModelSafeRoutingInfo& routes, + const std::string& payload); + +std::string ModelTypePayloadMapToString( + const ModelTypePayloadMap& model_type_payloads); + +// Caller takes ownership of the returned dictionary. +base::DictionaryValue* ModelTypePayloadMapToValue( + const ModelTypePayloadMap& model_type_payloads); + +// Coalesce |update| into |original|, overwriting only when |update| has +// a non-empty payload. +void CoalescePayloads(ModelTypePayloadMap* original, + const ModelTypePayloadMap& update); + +void PurgeStalePayload(ModelTypePayloadMap* original, + const browser_sync::ModelSafeRoutingInfo& routing_info); + +} // namespace syncable + +#endif // SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_PAYLOAD_MAP_H_ diff --git a/sync/internal_api/public/syncable/model_type_payload_map_unittest.cc b/sync/internal_api/public/syncable/model_type_payload_map_unittest.cc new file mode 100644 index 0000000..4a18b34 --- /dev/null +++ b/sync/internal_api/public/syncable/model_type_payload_map_unittest.cc @@ -0,0 +1,46 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/syncable/model_type_payload_map.h" + +#include + +#include "base/base64.h" +#include "base/memory/scoped_ptr.h" +#include "base/test/values_test_util.h" +#include "base/values.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace syncable { +namespace { + +using base::ExpectDictStringValue; + +class ModelTypePayloadMapTest : public testing::Test {}; + +TEST_F(ModelTypePayloadMapTest, TypePayloadMapToSet) { + ModelTypePayloadMap payloads; + payloads[BOOKMARKS] = "bookmarkpayload"; + payloads[APPS] = ""; + + const ModelTypeSet types(BOOKMARKS, APPS); + EXPECT_TRUE(ModelTypePayloadMapToEnumSet(payloads).Equals(types)); +} + +TEST_F(ModelTypePayloadMapTest, TypePayloadMapToValue) { + ModelTypePayloadMap payloads; + std::string encoded; + payloads[BOOKMARKS] = "bookmarkpayload"; + base::Base64Encode(payloads[BOOKMARKS], &encoded); + payloads[APPS] = ""; + + scoped_ptr value(ModelTypePayloadMapToValue(payloads)); + EXPECT_EQ(2u, value->size()); + ExpectDictStringValue(encoded, *value, "Bookmarks"); + ExpectDictStringValue("", *value, "Apps"); + EXPECT_FALSE(value->HasKey("Preferences")); +} + +} // namespace +} // namespace syncable diff --git a/sync/internal_api/public/syncable/model_type_test_util.cc b/sync/internal_api/public/syncable/model_type_test_util.cc new file mode 100644 index 0000000..36d1673 --- /dev/null +++ b/sync/internal_api/public/syncable/model_type_test_util.cc @@ -0,0 +1,52 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/syncable/model_type_test_util.h" + +namespace syncable { + +void PrintTo(ModelTypeSet model_types, ::std::ostream* os) { + *os << ModelTypeSetToString(model_types); +} + +namespace { + +// Matcher implementation for HasModelTypes(). +class HasModelTypesMatcher + : public ::testing::MatcherInterface { + public: + explicit HasModelTypesMatcher(ModelTypeSet expected_types) + : expected_types_(expected_types) {} + + virtual ~HasModelTypesMatcher() {} + + virtual bool MatchAndExplain( + ModelTypeSet model_types, + ::testing::MatchResultListener* listener) const { + // No need to annotate listener since we already define PrintTo(). + return model_types.Equals(expected_types_); + } + + virtual void DescribeTo(::std::ostream* os) const { + *os << "has model types " << ModelTypeSetToString(expected_types_); + } + + virtual void DescribeNegationTo(::std::ostream* os) const { + *os << "doesn't have model types " + << ModelTypeSetToString(expected_types_); + } + + private: + const ModelTypeSet expected_types_; + + DISALLOW_COPY_AND_ASSIGN(HasModelTypesMatcher); +}; + +} // namespace + +::testing::Matcher HasModelTypes(ModelTypeSet expected_types) { + return ::testing::MakeMatcher(new HasModelTypesMatcher(expected_types)); +} + +} // namespace syncable diff --git a/sync/internal_api/public/syncable/model_type_test_util.h b/sync/internal_api/public/syncable/model_type_test_util.h new file mode 100644 index 0000000..173212f --- /dev/null +++ b/sync/internal_api/public/syncable/model_type_test_util.h @@ -0,0 +1,26 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_TEST_UTIL_H_ +#define SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_TEST_UTIL_H_ +#pragma once + +#include + +#include "sync/internal_api/public/syncable/model_type.h" +#include "testing/gmock/include/gmock/gmock.h" + +namespace syncable { + +// Defined for googletest. Forwards to ModelTypeSetToString(). +void PrintTo(ModelTypeSet model_types, ::std::ostream* os); + +// A gmock matcher for ModelTypeSet. Use like: +// +// EXPECT_CALL(mock, ProcessModelTypes(HasModelTypes(expected_types))); +::testing::Matcher HasModelTypes(ModelTypeSet expected_types); + +} // namespace syncable + +#endif // SYNC_INTERNAL_PUBLIC_API_SYNCABLE_MODEL_TYPE_TEST_UTIL_H_ diff --git a/sync/internal_api/public/util/enum_set.h b/sync/internal_api/public/util/enum_set.h new file mode 100644 index 0000000..de270d8 --- /dev/null +++ b/sync/internal_api/public/util/enum_set.h @@ -0,0 +1,286 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_UTIL_ENUM_SET_H_ +#define SYNC_INTERNAL_API_PUBLIC_UTIL_ENUM_SET_H_ +#pragma once + +#include +#include +#include + +#include "base/basictypes.h" +#include "base/logging.h" + +namespace browser_sync { + +// Forward declarations needed for friend declarations. +template +class EnumSet; + +template +EnumSet Union(EnumSet set1, + EnumSet set2); + +template +EnumSet Intersection(EnumSet set1, + EnumSet set2); + +template +EnumSet Difference(EnumSet set1, + EnumSet set2); + +// An EnumSet is a set that can hold enum values between a min and a +// max value (inclusive of both). It's essentially a wrapper around +// std::bitset<> with stronger type enforcement, more descriptive +// member function names, and an iterator interface. +// +// If you're working with enums with a small number of possible values +// (say, fewer than 64), you can efficiently pass around an EnumSet +// for that enum around by value. + +template +class EnumSet { + public: + typedef E EnumType; + static const E kMinValue = MinEnumValue; + static const E kMaxValue = MaxEnumValue; + static const size_t kValueCount = kMaxValue - kMinValue + 1; + COMPILE_ASSERT(kMinValue < kMaxValue, + min_value_must_be_less_than_max_value); + + private: + // Declaration needed by Iterator. + typedef std::bitset EnumBitSet; + + public: + // Iterator is a forward-only read-only iterator for EnumSet. Its + // interface is deliberately distinct from an STL iterator as its + // semantics are substantially different. + // + // Example usage: + // + // for (EnumSet<...>::Iterator it = enums.First(); it.Good(); it.Inc()) { + // Process(it.Get()); + // } + // + // The iterator must not be outlived by the set. In particular, the + // following is an error: + // + // EnumSet<...> SomeFn() { ... } + // + // /* ERROR */ + // for (EnumSet<...>::Iterator it = SomeFun().First(); ... + // + // Also, there are no guarantees as to what will happen if you + // modify an EnumSet while traversing it with an iterator. + class Iterator { + public: + // A default-constructed iterator can't do anything except check + // Good(). You need to call First() on an EnumSet to get a usable + // iterator. + Iterator() : enums_(NULL), i_(kValueCount) {} + ~Iterator() {} + + // Copy constructor and assignment welcome. + + // Returns true iff the iterator points to an EnumSet and it + // hasn't yet traversed the EnumSet entirely. + bool Good() const { + return enums_ && i_ < kValueCount && enums_->test(i_); + } + + // Returns the value the iterator currently points to. Good() + // must hold. + E Get() const { + CHECK(Good()); + return FromIndex(i_); + } + + // Moves the iterator to the next value in the EnumSet. Good() + // must hold. Takes linear time. + void Inc() { + CHECK(Good()); + i_ = FindNext(i_ + 1); + } + + private: + friend Iterator EnumSet::First() const; + + explicit Iterator(const EnumBitSet& enums) + : enums_(&enums), i_(FindNext(0)) {} + + size_t FindNext(size_t i) { + while ((i < kValueCount) && !enums_->test(i)) { + ++i; + } + return i; + } + + const EnumBitSet* enums_; + size_t i_; + }; + + // You can construct an EnumSet with 0, 1, 2, or 3 initial values. + + EnumSet() {} + + explicit EnumSet(E value) { + Put(value); + } + + EnumSet(E value1, E value2) { + Put(value1); + Put(value2); + } + + EnumSet(E value1, E value2, E value3) { + Put(value1); + Put(value2); + Put(value3); + } + + // Returns an EnumSet with all possible values. + static EnumSet All() { + EnumBitSet enums; + enums.set(); + return EnumSet(enums); + } + + ~EnumSet() {} + + // Copy constructor and assignment welcome. + + // Set operations. Put, Retain, and Remove are basically + // self-mutating versions of Union, Intersection, and Difference + // (defined below). + + // Adds the given value (which must be in range) to our set. + void Put(E value) { + enums_.set(ToIndex(value)); + } + + // Adds all values in the given set to our set. + void PutAll(EnumSet other) { + enums_ |= other.enums_; + } + + // There's no real need for a Retain(E) member function. + + // Removes all values not in the given set from our set. + void RetainAll(EnumSet other) { + enums_ &= other.enums_; + } + + // If the given value is in range, removes it from our set. + void Remove(E value) { + if (InRange(value)) { + enums_.reset(ToIndex(value)); + } + } + + // Removes all values in the given set from our set. + void RemoveAll(EnumSet other) { + enums_ &= ~other.enums_; + } + + // Removes all values from our set. + void Clear() { + enums_.reset(); + } + + // Returns true iff the given value is in range and a member of our + // set. + bool Has(E value) const { + return InRange(value) && enums_.test(ToIndex(value)); + } + + // Returns true iff the given set is a subset of our set. + bool HasAll(EnumSet other) const { + return (enums_ & other.enums_) == other.enums_; + } + + // Returns true iff our set and the given set contain exactly the + // same values. + bool Equals(const EnumSet& other) const { + return enums_ == other.enums_; + } + + // Returns true iff our set is empty. + bool Empty() const { + return !enums_.any(); + } + + // Returns how many values our set has. + size_t Size() const { + return enums_.count(); + } + + // Returns an iterator pointing to the first element (if any). + Iterator First() const { + return Iterator(enums_); + } + + private: + friend EnumSet Union( + EnumSet set1, EnumSet set2); + friend EnumSet Intersection( + EnumSet set1, EnumSet set2); + friend EnumSet Difference( + EnumSet set1, EnumSet set2); + + explicit EnumSet(EnumBitSet enums) : enums_(enums) {} + + static bool InRange(E value) { + return (value >= MinEnumValue) && (value <= MaxEnumValue); + } + + // Converts a value to/from an index into |enums_|. + + static size_t ToIndex(E value) { + DCHECK_GE(value, MinEnumValue); + DCHECK_LE(value, MaxEnumValue); + return value - MinEnumValue; + } + + static E FromIndex(size_t i) { + DCHECK_LT(i, kValueCount); + return static_cast(MinEnumValue + i); + } + + EnumBitSet enums_; +}; + +template +const E EnumSet::kMinValue; + +template +const E EnumSet::kMaxValue; + +template +const size_t EnumSet::kValueCount; + +// The usual set operations. + +template +EnumSet Union(EnumSet set1, + EnumSet set2) { + return EnumSet(set1.enums_ | set2.enums_); +} + +template +EnumSet Intersection(EnumSet set1, + EnumSet set2) { + return EnumSet(set1.enums_ & set2.enums_); +} + +template +EnumSet Difference(EnumSet set1, + EnumSet set2) { + return EnumSet(set1.enums_ & ~set2.enums_); +} + +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_UTIL_ENUM_SET_H_ diff --git a/sync/internal_api/public/util/enum_set_unittest.cc b/sync/internal_api/public/util/enum_set_unittest.cc new file mode 100644 index 0000000..2caa1de --- /dev/null +++ b/sync/internal_api/public/util/enum_set_unittest.cc @@ -0,0 +1,195 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/util/enum_set.h" + +#include "base/basictypes.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace browser_sync { +namespace { + +enum TestEnum { + TEST_0, + TEST_MIN = TEST_0, + TEST_1, + TEST_2, + TEST_3, + TEST_4, + TEST_MAX = TEST_4, + TEST_5 +}; + +typedef EnumSet TestEnumSet; + +class EnumSetTest : public ::testing::Test {}; + +TEST_F(EnumSetTest, ClassConstants) { + TestEnumSet enums; + EXPECT_EQ(TEST_MIN, TestEnumSet::kMinValue); + EXPECT_EQ(TEST_MAX, TestEnumSet::kMaxValue); + EXPECT_EQ(static_cast(5), TestEnumSet::kValueCount); +} + +TEST_F(EnumSetTest, DefaultConstructor) { + const TestEnumSet enums; + EXPECT_TRUE(enums.Empty()); + EXPECT_EQ(static_cast(0), enums.Size()); + EXPECT_FALSE(enums.Has(TEST_0)); + EXPECT_FALSE(enums.Has(TEST_1)); + EXPECT_FALSE(enums.Has(TEST_2)); + EXPECT_FALSE(enums.Has(TEST_3)); + EXPECT_FALSE(enums.Has(TEST_4)); +} + +TEST_F(EnumSetTest, OneArgConstructor) { + const TestEnumSet enums(TEST_3); + EXPECT_FALSE(enums.Empty()); + EXPECT_EQ(static_cast(1), enums.Size()); + EXPECT_FALSE(enums.Has(TEST_0)); + EXPECT_FALSE(enums.Has(TEST_1)); + EXPECT_FALSE(enums.Has(TEST_2)); + EXPECT_TRUE(enums.Has(TEST_3)); + EXPECT_FALSE(enums.Has(TEST_4)); +} + +TEST_F(EnumSetTest, TwoArgConstructor) { + const TestEnumSet enums(TEST_3, TEST_1); + EXPECT_FALSE(enums.Empty()); + EXPECT_EQ(static_cast(2), enums.Size()); + EXPECT_FALSE(enums.Has(TEST_0)); + EXPECT_TRUE(enums.Has(TEST_1)); + EXPECT_FALSE(enums.Has(TEST_2)); + EXPECT_TRUE(enums.Has(TEST_3)); + EXPECT_FALSE(enums.Has(TEST_4)); +} + +TEST_F(EnumSetTest, ThreeArgConstructor) { + const TestEnumSet enums(TEST_3, TEST_1, TEST_0); + EXPECT_FALSE(enums.Empty()); + EXPECT_EQ(static_cast(3), enums.Size()); + EXPECT_TRUE(enums.Has(TEST_0)); + EXPECT_TRUE(enums.Has(TEST_1)); + EXPECT_FALSE(enums.Has(TEST_2)); + EXPECT_TRUE(enums.Has(TEST_3)); + EXPECT_FALSE(enums.Has(TEST_4)); +} + +TEST_F(EnumSetTest, All) { + const TestEnumSet enums(TestEnumSet::All()); + EXPECT_FALSE(enums.Empty()); + EXPECT_EQ(static_cast(5), enums.Size()); + EXPECT_TRUE(enums.Has(TEST_0)); + EXPECT_TRUE(enums.Has(TEST_1)); + EXPECT_TRUE(enums.Has(TEST_2)); + EXPECT_TRUE(enums.Has(TEST_3)); + EXPECT_TRUE(enums.Has(TEST_4)); +} + +TEST_F(EnumSetTest, Put) { + TestEnumSet enums(TEST_3); + enums.Put(TEST_2); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_2, TEST_3))); + enums.Put(TEST_4); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_2, TEST_3, TEST_4))); +} + +TEST_F(EnumSetTest, PutAll) { + TestEnumSet enums(TEST_3, TEST_4); + enums.PutAll(TestEnumSet(TEST_2, TEST_3)); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_2, TEST_3, TEST_4))); +} + +TEST_F(EnumSetTest, RetainAll) { + TestEnumSet enums(TEST_3, TEST_4); + enums.RetainAll(TestEnumSet(TEST_2, TEST_3)); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_3))); +} + +TEST_F(EnumSetTest, Remove) { + TestEnumSet enums(TEST_3, TEST_4); + enums.Remove(TEST_0); + enums.Remove(TEST_2); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_3, TEST_4))); + enums.Remove(TEST_3); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_4))); + enums.Remove(TEST_4); + enums.Remove(TEST_5); + EXPECT_TRUE(enums.Empty()); +} + +TEST_F(EnumSetTest, RemoveAll) { + TestEnumSet enums(TEST_3, TEST_4); + enums.RemoveAll(TestEnumSet(TEST_2, TEST_3)); + EXPECT_TRUE(enums.Equals(TestEnumSet(TEST_4))); +} + +TEST_F(EnumSetTest, Clear) { + TestEnumSet enums(TEST_3, TEST_4); + enums.Clear(); + EXPECT_TRUE(enums.Empty()); +} + +TEST_F(EnumSetTest, Has) { + const TestEnumSet enums(TEST_3, TEST_4); + EXPECT_FALSE(enums.Has(TEST_0)); + EXPECT_FALSE(enums.Has(TEST_1)); + EXPECT_FALSE(enums.Has(TEST_2)); + EXPECT_TRUE(enums.Has(TEST_3)); + EXPECT_TRUE(enums.Has(TEST_4)); + EXPECT_FALSE(enums.Has(TEST_5)); +} + +TEST_F(EnumSetTest, HasAll) { + const TestEnumSet enums1(TEST_3, TEST_4); + const TestEnumSet enums2(TEST_2, TEST_3); + const TestEnumSet enums3 = Union(enums1, enums2); + EXPECT_TRUE(enums1.HasAll(enums1)); + EXPECT_FALSE(enums1.HasAll(enums2)); + EXPECT_FALSE(enums1.HasAll(enums3)); + + EXPECT_FALSE(enums2.HasAll(enums1)); + EXPECT_TRUE(enums2.HasAll(enums2)); + EXPECT_FALSE(enums2.HasAll(enums3)); + + EXPECT_TRUE(enums3.HasAll(enums1)); + EXPECT_TRUE(enums3.HasAll(enums2)); + EXPECT_TRUE(enums3.HasAll(enums3)); +} + +TEST_F(EnumSetTest, Iterators) { + const TestEnumSet enums1(TEST_3, TEST_4); + TestEnumSet enums2; + for (TestEnumSet::Iterator it = enums1.First(); it.Good(); it.Inc()) { + enums2.Put(it.Get()); + } + EXPECT_TRUE(enums1.Equals(enums2)); +} + +TEST_F(EnumSetTest, Union) { + const TestEnumSet enums1(TEST_3, TEST_4); + const TestEnumSet enums2(TEST_2, TEST_3); + const TestEnumSet enums3 = Union(enums1, enums2); + + EXPECT_TRUE(enums3.Equals(TestEnumSet(TEST_2, TEST_3, TEST_4))); +} + +TEST_F(EnumSetTest, Intersection) { + const TestEnumSet enums1(TEST_3, TEST_4); + const TestEnumSet enums2(TEST_2, TEST_3); + const TestEnumSet enums3 = Intersection(enums1, enums2); + + EXPECT_TRUE(enums3.Equals(TestEnumSet(TEST_3))); +} + +TEST_F(EnumSetTest, Difference) { + const TestEnumSet enums1(TEST_3, TEST_4); + const TestEnumSet enums2(TEST_2, TEST_3); + const TestEnumSet enums3 = Difference(enums1, enums2); + + EXPECT_TRUE(enums3.Equals(TestEnumSet(TEST_4))); +} + +} // namespace +} // namespace browser_sync diff --git a/sync/internal_api/public/util/syncer_error.cc b/sync/internal_api/public/util/syncer_error.cc new file mode 100644 index 0000000..b4ba578 --- /dev/null +++ b/sync/internal_api/public/util/syncer_error.cc @@ -0,0 +1,36 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "sync/internal_api/public/util/syncer_error.h" + +#include "base/logging.h" + +namespace browser_sync { + +#define ENUM_CASE(x) case x: return #x; break; +const char* GetSyncerErrorString(SyncerError value) { + switch (value) { + ENUM_CASE(UNSET); + ENUM_CASE(DIRECTORY_LOOKUP_FAILED); + ENUM_CASE(NETWORK_CONNECTION_UNAVAILABLE); + ENUM_CASE(NETWORK_IO_ERROR); + ENUM_CASE(SYNC_SERVER_ERROR); + ENUM_CASE(SYNC_AUTH_ERROR); + ENUM_CASE(SERVER_RETURN_INVALID_CREDENTIAL); + ENUM_CASE(SERVER_RETURN_UNKNOWN_ERROR); + ENUM_CASE(SERVER_RETURN_THROTTLED); + ENUM_CASE(SERVER_RETURN_TRANSIENT_ERROR); + ENUM_CASE(SERVER_RETURN_MIGRATION_DONE); + ENUM_CASE(SERVER_RETURN_CLEAR_PENDING); + ENUM_CASE(SERVER_RETURN_NOT_MY_BIRTHDAY); + ENUM_CASE(SERVER_RESPONSE_VALIDATION_FAILED); + ENUM_CASE(SYNCER_OK); + } + NOTREACHED(); + return "INVALID"; +} +#undef ENUM_CASE + +} // namespace browser_sync + diff --git a/sync/internal_api/public/util/syncer_error.h b/sync/internal_api/public/util/syncer_error.h new file mode 100644 index 0000000..aa6ebb3 --- /dev/null +++ b/sync/internal_api/public/util/syncer_error.h @@ -0,0 +1,46 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef SYNC_INTERNAL_API_PUBLIC_UTIL_SYNCER_ERROR_H_ +#define SYNC_INTERNAL_API_PUBLIC_UTIL_SYNCER_ERROR_H_ +#pragma once + +namespace browser_sync { + +// This enum describes all the ways a SyncerCommand can fail. +// +// SyncerCommands do many different things, but they share a common function +// signature. This enum, the return value for all SyncerCommands, must be able +// to describe any possible failure for all SyncerComand. +// +// For convenience, functions which are invoked only by SyncerCommands may also +// return a SyncerError. It saves us having to write a conversion function, and +// it makes refactoring easier. +enum SyncerError { + UNSET = 0, // Default value. + DIRECTORY_LOOKUP_FAILED, // Local directory lookup failure. + + NETWORK_CONNECTION_UNAVAILABLE, // Connectivity failure. + NETWORK_IO_ERROR, // Response buffer read error. + SYNC_SERVER_ERROR, // Non auth HTTP error. + SYNC_AUTH_ERROR, // HTTP auth error. + + // Based on values returned by server. Most are defined in sync.proto. + SERVER_RETURN_INVALID_CREDENTIAL, + SERVER_RETURN_UNKNOWN_ERROR, + SERVER_RETURN_THROTTLED, + SERVER_RETURN_TRANSIENT_ERROR, + SERVER_RETURN_MIGRATION_DONE, + SERVER_RETURN_CLEAR_PENDING, + SERVER_RETURN_NOT_MY_BIRTHDAY, + SERVER_RESPONSE_VALIDATION_FAILED, + + SYNCER_OK +}; + +const char * GetSyncerErrorString(SyncerError); + +} // namespace browser_sync + +#endif // SYNC_INTERNAL_API_PUBLIC_UTIL_SYNCER_ERROR_H_ -- cgit v1.1