Speculative revert by sheriff

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 <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 16 matching lines @@
 #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::ModelType;
 using syncer::ModelTypeSet;
 
+// The default store birthday value.
+static const char kDefaultStoreBirthday[] = "1234567890";
+
+// The default keystore key.
+static const char kDefaultKeystoreKey[] = "1111111111111111";
+
 namespace fake_server {
 
 class FakeServerEntity;
 
 namespace {
 
-// The default store birthday value.
-static const char kDefaultStoreBirthday[] = "1234567890";
-
-// 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 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() { }
 
   // Factory method for creating an UpdateSieve.
   static scoped_ptr<UpdateSieve> Create(
       const sync_pb::GetUpdatesMessage& get_updates_message);
@@ skipping 101 matching lines @@
                            request_counter_(0),
                            network_enabled_(true) {
   keystore_keys_.push_back(kDefaultKeystoreKey);
   CHECK(CreateDefaultPermanentItems());
 }
 
 FakeServer::~FakeServer() {
   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 }
 
-bool FakeServer::CreatePermanentBookmarkFolder(const std::string& server_tag,
-                                               const std::string& name) {
+bool FakeServer::CreatePermanentBookmarkFolder(const char* server_tag,
+                                               const char* name) {
   FakeServerEntity* entity =
       PermanentEntity::Create(syncer::BOOKMARKS, server_tag, name,
                               ModelTypeToRootTag(syncer::BOOKMARKS));
   if (entity == NULL)
     return false;
 
   SaveEntity(entity);
   return true;
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
   ModelTypeSet all_types = syncer::ProtocolTypes();
   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
     ModelType model_type = it.Get();
     FakeServerEntity* top_level_entity =
         PermanentEntity::CreateTopLevel(model_type);
     if (top_level_entity == NULL) {
       return false;
     }
     SaveEntity(top_level_entity);
 
     if (model_type == syncer::BOOKMARKS) {
-      if (!CreatePermanentBookmarkFolder(kBookmarkBarFolderServerTag,
-                                         kBookmarkBarFolderName))
+      if (!CreatePermanentBookmarkFolder("bookmark_bar", "Bookmark Bar"))
         return false;
-      if (!CreatePermanentBookmarkFolder(kOtherBookmarksFolderServerTag,
-                                         kOtherBookmarksFolderName))
+      if (!CreatePermanentBookmarkFolder("other_bookmarks", "Other Bookmarks"))
         return false;
     }
   }
 
   return true;
 }
 
+bool FakeServer::CreateMobileBookmarksPermanentItem() {
+  // This folder is called "Synced Bookmarks" by sync and is renamed
+  // "Mobile Bookmarks" by the mobile client UIs.
+  FakeServerEntity* mobile_bookmarks_entity =
+      PermanentEntity::Create(syncer::BOOKMARKS,
+                              "synced_bookmarks",
+                              "Synced Bookmarks",
+                              ModelTypeToRootTag(syncer::BOOKMARKS));
+  if (mobile_bookmarks_entity == NULL) {
+    return false;
+  }
+  SaveEntity(mobile_bookmarks_entity);
+  return true;
+}
+
 void FakeServer::SaveEntity(FakeServerEntity* entity) {
   delete entities_[entity->GetId()];
   entity->SetVersion(++version_);
   entities_[entity->GetId()] = entity;
 }
 
 void FakeServer::HandleCommand(const string& request,
                                const HandleCommandCallback& callback) {
   if (!network_enabled_) {
     callback.Run(net::ERR_FAILED, net::ERR_FAILED, string());
@@ skipping 55 matching lines @@
 
 bool FakeServer::HandleGetUpdatesRequest(
     const sync_pb::GetUpdatesMessage& get_updates,
     sync_pb::GetUpdatesResponse* response) {
   // TODO(pvalenzuela): Implement batching instead of sending all information
   // at once.
   response->set_changes_remaining(0);
 
   scoped_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
 
-  // This folder is called "Synced Bookmarks" by sync and is renamed
-  // "Mobile Bookmarks" by the mobile client UIs.
   if (get_updates.create_mobile_bookmarks_folder() &&
-      !CreatePermanentBookmarkFolder(kSyncedBookmarksFolderServerTag,
-                                     kSyncedBookmarksFolderName)) {
+      !CreateMobileBookmarksPermanentItem()) {
     return false;
   }
 
   bool send_encryption_keys_based_on_nigori = false;
   int64 max_response_version = 0;
   for (EntityMap::iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     FakeServerEntity* entity = it->second;
     if (sieve->ClientWantsItem(entity)) {
       sync_pb::SyncEntity* response_entity = response->add_entries();
@@ skipping 288 matching lines @@
 }
 
 void FakeServer::EnableNetwork() {
   network_enabled_ = true;
 }
 
 void FakeServer::DisableNetwork() {
   network_enabled_ = false;
 }
 
-std::string FakeServer::GetBookmarkBarFolderId() const {
-  for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
-       ++it) {
-    FakeServerEntity* entity = it->second;
-    if (entity->GetName() == kBookmarkBarFolderName &&
-        entity->IsFolder() &&
-        entity->GetModelType() == syncer::BOOKMARKS) {
-      return entity->GetId();
-    }
-  }
-  NOTREACHED() << "Bookmark Bar entity not found.";
-  return "";
-}
-
 }  // namespace fake_server