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

components/sync/test/fake_server/fake_server.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/test/fake_server/fake_server.h"
+#include "components/sync/test/fake_server/fake_server.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/protocol/sync.pb.h"
+#include "components/sync/test/fake_server/bookmark_entity.h"
+#include "components/sync/test/fake_server/permanent_entity.h"
+#include "components/sync/test/fake_server/tombstone_entity.h"
+#include "components/sync/test/fake_server/unique_client_entity.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/test/fake_server/bookmark_entity.h"
-#include "sync/test/fake_server/permanent_entity.h"
-#include "sync/test/fake_server/tombstone_entity.h"
-#include "sync/test/fake_server/unique_client_entity.h"
 
 using std::string;
 using std::vector;
 
 using syncer::GetModelType;
 using syncer::GetModelTypeFromSpecifics;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 
 namespace fake_server {
 
 class FakeServerEntity;
 
 namespace {
 
 // The default keystore key.
 static const char kDefaultKeystoreKey[] = "1111111111111111";
 
 // Properties of the bookmark bar permanent folder.
 static const char kBookmarkBarFolderServerTag[] = "bookmark_bar";
 static const char kBookmarkBarFolderName[] = "Bookmark Bar";
 
 // Properties of the other bookmarks permanent folder.
-static const char kOtherBookmarksFolderServerTag[] =  "other_bookmarks";
+static const char kOtherBookmarksFolderServerTag[] = "other_bookmarks";
 static const char kOtherBookmarksFolderName[] = "Other Bookmarks";
 
 // Properties of the synced bookmarks permanent folder.
 static const char kSyncedBookmarksFolderServerTag[] = "synced_bookmarks";
 static const char kSyncedBookmarksFolderName[] = "Synced Bookmarks";
 
 // A filter used during GetUpdates calls to determine what information to
 // send back to the client. There is a 1:1 correspondence between any given
 // GetUpdates call and an UpdateSieve instance.
 class UpdateSieve {
  public:
-  ~UpdateSieve() { }
+  ~UpdateSieve() {}
 
   // Factory method for creating an UpdateSieve.
   static std::unique_ptr<UpdateSieve> Create(
       const sync_pb::GetUpdatesMessage& get_updates_message);
 
   // Sets the progress markers in |get_updates_response| given the progress
   // markers from the original GetUpdatesMessage and |new_version| (the latest
   // version in the entries sent back).
   void UpdateProgressMarkers(
       int64_t new_version,
@@ skipping 58 matching lines @@
         get_updates_message.from_progress_marker(i);
 
     int64_t version = 0;
     // Let the version remain zero if there is no token or an empty token (the
     // first request for this type).
     if (marker.has_token() && !marker.token().empty()) {
       bool parsed = base::StringToInt64(marker.token(), &version);
       CHECK(parsed) << "Unable to parse progress marker token.";
     }
 
-    ModelType model_type = syncer::GetModelTypeFromSpecificsFieldNumber(
-        marker.data_type_id());
+    ModelType model_type =
+        syncer::GetModelTypeFromSpecificsFieldNumber(marker.data_type_id());
     request_from_version[model_type] = version;
 
     if (version < min_version)
       min_version = version;
   }
 
   return std::unique_ptr<UpdateSieve>(
       new UpdateSieve(request_from_version, min_version));
 }
 
 // Returns whether |entity| is deleted or permanent.
 bool IsDeletedOrPermanent(const FakeServerEntity& entity) {
   return entity.IsDeleted() || entity.IsPermanent();
 }
 
 }  // namespace
 
-FakeServer::FakeServer() : version_(0),
-                           store_birthday_(0),
-                           authenticated_(true),
-                           error_type_(sync_pb::SyncEnums::SUCCESS),
-                           alternate_triggered_errors_(false),
-                           request_counter_(0),
-                           network_enabled_(true),
-                           weak_ptr_factory_(this) {
+FakeServer::FakeServer()
+    : version_(0),
+      store_birthday_(0),
+      authenticated_(true),
+      error_type_(sync_pb::SyncEnums::SUCCESS),
+      alternate_triggered_errors_(false),
+      request_counter_(0),
+      network_enabled_(true),
+      weak_ptr_factory_(this) {
   Init();
 }
 
 FakeServer::~FakeServer() {}
 
 void FakeServer::Init() {
   keystore_keys_.push_back(kDefaultKeystoreKey);
 
   const bool create_result = CreateDefaultPermanentItems();
   DCHECK(create_result) << "Permanent items were not created successfully.";
@@ skipping 131 matching lines @@
   }
 
   response_proto.set_store_birthday(GetStoreBirthday());
 
   *error_code = 0;
   *response_code = net::HTTP_OK;
   *response = response_proto.SerializeAsString();
   completion_closure.Run();
 }
 
-bool FakeServer::GetLastCommitMessage(
-    sync_pb::ClientToServerMessage* message) {
+bool FakeServer::GetLastCommitMessage(sync_pb::ClientToServerMessage* message) {
   if (!last_commit_message_.has_commit())
     return false;
 
   message->CopyFrom(last_commit_message_);
   return true;
 }
 
 bool FakeServer::GetLastGetUpdatesMessage(
     sync_pb::ClientToServerMessage* message) {
   if (!last_getupdates_message_.has_get_updates())
@@ skipping 22 matching lines @@
 
   bool send_encryption_keys_based_on_nigori = false;
   int64_t max_response_version = 0;
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (sieve->ClientWantsItem(entity)) {
       sync_pb::SyncEntity* response_entity = response->add_entries();
       entity.SerializeAsProto(response_entity);
 
-      max_response_version = std::max(max_response_version,
-                                      response_entity->version());
+      max_response_version =
+          std::max(max_response_version, response_entity->version());
 
       if (entity.GetModelType() == syncer::NIGORI) {
         send_encryption_keys_based_on_nigori =
             response_entity->specifics().nigori().passphrase_type() ==
-                sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE;
+            sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE;
       }
     }
   }
 
   if (send_encryption_keys_based_on_nigori ||
       get_updates.need_encryption_key()) {
     for (vector<string>::iterator it = keystore_keys_.begin();
          it != keystore_keys_.end(); ++it) {
       response->add_encryption_keys(*it);
     }
@@ skipping 103 matching lines @@
   ModelTypeSet committed_model_types;
 
   // TODO(pvalenzuela): Add validation of CommitMessage.entries.
   ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>::const_iterator it;
   for (it = commit.entries().begin(); it != commit.entries().end(); ++it) {
     sync_pb::CommitResponse_EntryResponse* entry_response =
         response->add_entryresponse();
 
     sync_pb::SyncEntity client_entity = *it;
     string parent_id = client_entity.parent_id_string();
-    if (client_to_server_ids.find(parent_id) !=
-        client_to_server_ids.end()) {
+    if (client_to_server_ids.find(parent_id) != client_to_server_ids.end()) {
       parent_id = client_to_server_ids[parent_id];
     }
 
     const string entity_id =
         CommitEntity(client_entity, entry_response, guid, parent_id);
     if (entity_id.empty()) {
       return false;
     }
 
     // Record the ID if it was renamed.
@@ skipping 196 matching lines @@
 void FakeServer::DisableNetwork() {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_enabled_ = false;
 }
 
 std::string FakeServer::GetBookmarkBarFolderId() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     FakeServerEntity* entity = it->second.get();
-    if (entity->GetName() == kBookmarkBarFolderName &&
-        entity->IsFolder() &&
+    if (entity->GetName() == kBookmarkBarFolderName && entity->IsFolder() &&
         entity->GetModelType() == syncer::BOOKMARKS) {
       return entity->GetId();
     }
   }
   NOTREACHED() << "Bookmark Bar entity not found.";
   return "";
 }
 
 base::WeakPtr<FakeServer> FakeServer::AsWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server