Revert "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;
 
+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";
 
-namespace fake_server {
+// Properties of the bookmark bar permanent folder.
+static const char kBookmarkBarFolderServerTag[] = "bookmark_bar";
+static const char kBookmarkBarFolderName[] = "Bookmark Bar";
 
-class FakeServerEntity;
+// Properties of the other bookmarks permanent folder.
+static const char kOtherBookmarksFolderServerTag[] =  "other_bookmarks";
+static const char kOtherBookmarksFolderName[] = "Other Bookmarks";
 
-namespace {
+// 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(
@@ skipping 102 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 char* server_tag,
-                                               const char* name) {
+bool FakeServer::CreatePermanentBookmarkFolder(const std::string& server_tag,
+                                               const std::string& 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("bookmark_bar", "Bookmark Bar"))
+      if (!CreatePermanentBookmarkFolder(kBookmarkBarFolderServerTag,
+                                         kBookmarkBarFolderName))
         return false;
-      if (!CreatePermanentBookmarkFolder("other_bookmarks", "Other Bookmarks"))
+      if (!CreatePermanentBookmarkFolder(kOtherBookmarksFolderServerTag,
+                                         kOtherBookmarksFolderName))
         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() &&
-      !CreateMobileBookmarksPermanentItem()) {
+      !CreatePermanentBookmarkFolder(kSyncedBookmarksFolderServerTag,
+                                     kSyncedBookmarksFolderName)) {
     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