[Sync] Move //sync to //components/sync.

components/sync/test/engine/mock_connection_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
-#include "sync/test/engine/mock_connection_manager.h"
+#include "components/sync/test/engine/mock_connection_manager.h"
 
 #include <stdint.h>
 
 #include <map>
 
 #include "base/location.h"
 #include "base/strings/stringprintf.h"
-#include "sync/engine/syncer_proto_util.h"
-#include "sync/protocol/bookmark_specifics.pb.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/syncable_write_transaction.h"
-#include "sync/test/engine/test_id_factory.h"
+#include "components/sync/engine_impl/syncer_proto_util.h"
+#include "components/sync/protocol/bookmark_specifics.pb.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/syncable_write_transaction.h"
+#include "components/sync/test/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::find;
 using std::map;
 using std::string;
 using sync_pb::ClientToServerMessage;
 using sync_pb::CommitMessage;
 using sync_pb::CommitResponse;
 using sync_pb::GetUpdatesMessage;
 using sync_pb::SyncEnums;
@@ skipping 36 matching lines @@
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallback(
     const base::Closure& callback) {
   mid_commit_callback_ = callback;
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
-    mid_commit_observer_ = observer;
+  mid_commit_observer_ = observer;
 }
 
 bool MockConnectionManager::PostBufferToPath(PostBufferParams* params,
                                              const string& path,
                                              const string& auth_token) {
   ClientToServerMessage post;
   CHECK(post.ParseFromString(params->buffer_in));
   CHECK(post.has_protocol_version());
   CHECK(post.has_api_key());
   CHECK(post.has_bag_of_chips());
@@ skipping 32 matching lines @@
   if (!server_reachable_) {
     params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
     return false;
   }
 
   // Default to an ok connection.
   params->response.server_status = HttpResponse::SERVER_CONNECTION_OK;
   response.set_error_code(SyncEnums::SUCCESS);
   const string current_store_birthday = store_birthday();
   response.set_store_birthday(current_store_birthday);
-  if (post.has_store_birthday() && post.store_birthday() !=
-      current_store_birthday) {
+  if (post.has_store_birthday() &&
+      post.store_birthday() != current_store_birthday) {
     response.set_error_code(SyncEnums::NOT_MY_BIRTHDAY);
     response.set_error_message("Merry Unbirthday!");
     response.SerializeToString(&params->buffer_out);
     store_birthday_sent_ = true;
     return true;
   }
   bool result = true;
   EXPECT_TRUE(!store_birthday_sent_ || post.has_store_birthday() ||
               post.message_contents() == ClientToServerMessage::AUTHENTICATE ||
               post.message_contents() ==
@@ skipping 58 matching lines @@
     sync_pb::SyncEntity_BookmarkData* data = entity->mutable_bookmarkdata();
     data->set_bookmark_folder(is_folder);
 
     if (!is_folder) {
       data->set_bookmark_url("http://google.com");
     }
   } else {
     entity->set_folder(is_folder);
     entity->mutable_specifics()->mutable_bookmark();
     if (!is_folder) {
-      entity->mutable_specifics()->mutable_bookmark()->
-          set_url("http://google.com");
+      entity->mutable_specifics()->mutable_bookmark()->set_url(
+          "http://google.com");
     }
   }
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     int id,
     int parent_id,
     const string& name,
     int64_t version,
     int64_t sync_ts,
     const std::string& originator_cache_guid,
     const std::string& originator_client_item_id) {
-  return AddUpdateDirectory(TestIdFactory::FromNumber(id),
-                            TestIdFactory::FromNumber(parent_id),
-                            name,
-                            version,
-                            sync_ts,
-                            originator_cache_guid,
-                            originator_client_item_id);
+  return AddUpdateDirectory(
+      TestIdFactory::FromNumber(id), TestIdFactory::FromNumber(parent_id), name,
+      version, sync_ts, originator_cache_guid, originator_client_item_id);
 }
 
 void MockConnectionManager::SetGUClientCommand(
     sync_pb::ClientCommand* command) {
   gu_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetCommitClientCommand(
     sync_pb::ClientCommand* command) {
   commit_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetTransientErrorId(syncable::Id id) {
   transient_error_ids_.push_back(id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     int id,
     int parent_id,
     const string& name,
     int64_t version,
     int64_t sync_ts,
     const string& originator_client_item_id,
     const string& originator_cache_guid) {
-  return AddUpdateBookmark(TestIdFactory::FromNumber(id),
-                           TestIdFactory::FromNumber(parent_id),
-                           name,
-                           version,
-                           sync_ts,
-                           originator_client_item_id,
-                           originator_cache_guid);
+  return AddUpdateBookmark(
+      TestIdFactory::FromNumber(id), TestIdFactory::FromNumber(parent_id), name,
+      version, sync_ts, originator_client_item_id, originator_cache_guid);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
     const string& name,
     int64_t version,
     int64_t sync_ts,
     bool is_dir,
     int64_t position,
     const sync_pb::EntitySpecifics& specifics) {
-  sync_pb::SyncEntity* ent = AddUpdateMeta(
-      TestIdFactory::FromNumber(id).GetServerId(),
-      TestIdFactory::FromNumber(parent_id).GetServerId(),
-      name, version, sync_ts);
+  sync_pb::SyncEntity* ent =
+      AddUpdateMeta(TestIdFactory::FromNumber(id).GetServerId(),
+                    TestIdFactory::FromNumber(parent_id).GetServerId(), name,
+                    version, sync_ts);
   ent->set_position_in_parent(position);
   ent->mutable_specifics()->CopyFrom(specifics);
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
     const string& name,
@@ skipping 122 matching lines @@
       AddUpdateFull(id, parent_id, name, version, sync_ts, false);
   ret->set_originator_cache_guid(originator_cache_guid);
   ret->set_originator_client_item_id(originator_client_item_id);
   return ret;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
   EXPECT_EQ(1, last_sent_commit().entries_size());
   EXPECT_EQ(1, last_commit_response().entryresponse_size());
   EXPECT_EQ(CommitResponse::SUCCESS,
-      last_commit_response().entryresponse(0).response_type());
+            last_commit_response().entryresponse(0).response_type());
 
   if (last_sent_commit().entries(0).deleted()) {
     ModelType type = GetModelType(last_sent_commit().entries(0));
     AddUpdateTombstone(syncable::Id::CreateFromServerId(
-        last_sent_commit().entries(0).id_string()), type);
+                           last_sent_commit().entries(0).id_string()),
+                       type);
   } else {
     sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
     ent->CopyFrom(last_sent_commit().entries(0));
     ent->clear_insert_after_item_id();
     ent->clear_old_parent_id();
     ent->set_position_in_parent(
         last_commit_response().entryresponse(0).position_in_parent());
-    ent->set_version(
-        last_commit_response().entryresponse(0).version());
-    ent->set_id_string(
-        last_commit_response().entryresponse(0).id_string());
+    ent->set_version(last_commit_response().entryresponse(0).version());
+    ent->set_id_string(last_commit_response().entryresponse(0).id_string());
 
     // This is the same hack as in AddUpdateMeta.  See the comment in that
     // function for more information.
     ent->set_originator_cache_guid(kCacheGuid);
     ent->set_originator_client_item_id(
         last_commit_response().entryresponse(0).id_string());
 
     if (last_sent_commit().entries(0).has_unique_position()) {
       ent->mutable_unique_position()->CopyFrom(
           last_sent_commit().entries(0).unique_position());
     }
 
     // Tests don't currently care about the following:
     // parent_id_string, name, non_unique_name.
   }
   return GetMutableLastUpdate();
 }
 
-void MockConnectionManager::AddUpdateTombstone(
-    const syncable::Id& id,
-    ModelType type) {
+void MockConnectionManager::AddUpdateTombstone(const syncable::Id& id,
+                                               ModelType type) {
   // Tombstones have only the ID set and dummy values for the required fields.
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id.GetServerId());
   ent->set_version(0);
   ent->set_name("");
   ent->set_deleted(true);
 
   // Make sure we can still extract the ModelType from this tombstone.
   AddDefaultFieldValue(type, ent->mutable_specifics());
 }
@@ skipping 116 matching lines @@
   if (conflict_all_commits_) {
     conflict = true;
   } else if (conflict_n_commits_ > 0) {
     conflict = true;
     --conflict_n_commits_;
   }
   return conflict;
 }
 
 bool MockConnectionManager::ShouldTransientErrorThisId(syncable::Id id) {
-  return find(transient_error_ids_.begin(), transient_error_ids_.end(), id)
-      != transient_error_ids_.end();
+  return find(transient_error_ids_.begin(), transient_error_ids_.end(), id) !=
+         transient_error_ids_.end();
 }
 
 void MockConnectionManager::ProcessCommit(
     sync_pb::ClientToServerMessage* csm,
     sync_pb::ClientToServerResponse* response_buffer) {
   CHECK(csm->has_commit());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::COMMIT);
-  map <string, string> changed_ids;
+  map<string, string> changed_ids;
   const CommitMessage& commit_message = csm->commit();
   CommitResponse* commit_response = response_buffer->mutable_commit();
   commit_messages_.push_back(new CommitMessage);
   commit_messages_.back()->CopyFrom(commit_message);
   map<string, sync_pb::CommitResponse_EntryResponse*> response_map;
-  for (int i = 0; i < commit_message.entries_size() ; i++) {
+  for (int i = 0; i < commit_message.entries_size(); i++) {
     const sync_pb::SyncEntity& entry = commit_message.entries(i);
     CHECK(entry.has_id_string());
     string id_string = entry.id_string();
-    ASSERT_LT(entry.name().length(), 256ul) << " name probably too long. True "
-        "server name checking not implemented";
+    ASSERT_LT(entry.name().length(), 256ul)
+        << " name probably too long. True "
+           "server name checking not implemented";
     syncable::Id id;
     if (entry.version() == 0) {
       // Relies on our new item string id format. (string representation of a
       // negative number).
       id = syncable::Id::CreateFromClientString(id_string);
     } else {
       id = syncable::Id::CreateFromServerId(id_string);
     }
     committed_ids_.push_back(id);
 
@@ skipping 45 matching lines @@
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     syncable::Id id,
     syncable::Id parent_id,
     const string& name,
     int64_t version,
     int64_t sync_ts,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
-  return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
-                            name, version, sync_ts, originator_cache_guid,
+  return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(), name,
+                            version, sync_ts, originator_cache_guid,
                             originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id,
     syncable::Id parent_id,
     const string& name,
     int64_t version,
     int64_t sync_ts,
     const string& originator_cache_guid,
     const string& originator_client_item_id) {
-  return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
-                           name, version, sync_ts, originator_cache_guid,
+  return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(), name,
+                           version, sync_ts, originator_cache_guid,
                            originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
   sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
   EXPECT_GT(updates->entries_size(), 0);
   return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
 }
 
 void MockConnectionManager::NextUpdateBatch() {
   update_queue_.push_back(sync_pb::GetUpdatesResponse::default_instance());
   SetChangesRemaining(0);
   ApplyToken();
 }
 
 const CommitMessage& MockConnectionManager::last_sent_commit() const {
   EXPECT_TRUE(!commit_messages_.empty());
   return *commit_messages_.back();
 }
 
 const CommitResponse& MockConnectionManager::last_commit_response() const {
   EXPECT_TRUE(!commit_responses_.empty());
   return *commit_responses_.back();
 }
 
-const sync_pb::ClientToServerMessage&
-    MockConnectionManager::last_request() const {
+const sync_pb::ClientToServerMessage& MockConnectionManager::last_request()
+    const {
   EXPECT_TRUE(!requests_.empty());
   return requests_.back();
 }
 
 const std::vector<sync_pb::ClientToServerMessage>&
-    MockConnectionManager::requests() const {
+MockConnectionManager::requests() const {
   return requests_;
 }
 
 bool MockConnectionManager::IsModelTypePresentInSpecifics(
-    const google::protobuf::RepeatedPtrField<
-        sync_pb::DataTypeProgressMarker>& filter,
+    const google::protobuf::RepeatedPtrField<sync_pb::DataTypeProgressMarker>&
+        filter,
     ModelType value) {
   int data_type_id = GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return true;
     }
   }
   return false;
 }
 
 sync_pb::DataTypeProgressMarker const*
-    MockConnectionManager::GetProgressMarkerForType(
-        const google::protobuf::RepeatedPtrField<
-            sync_pb::DataTypeProgressMarker>& filter,
-        ModelType value) {
+MockConnectionManager::GetProgressMarkerForType(
+    const google::protobuf::RepeatedPtrField<sync_pb::DataTypeProgressMarker>&
+        filter,
+    ModelType value) {
   int data_type_id = GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return &(filter.Get(i));
     }
   }
   return NULL;
 }
 
 void MockConnectionManager::SetServerReachable() {
@@ skipping 11 matching lines @@
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 void MockConnectionManager::SetServerStatus(
     HttpResponse::ServerConnectionCode server_status) {
   server_status_ = server_status;
 }
 
 }  // namespace syncer