Add InjectEntity method to Sync FakeServer

This is the first CL to create the API to inject test data in the Sync
FakeServer.

Summary of changes:
1) Creation of FakeServer::InjectEntity
2) Creation of InjectedEntityBuilder (tests will use this API to create
   FakeServerEntity objects that will later be passed to InjectEntity)
3) Creation of a simple bookmark test to use this functionality
4) FakeServer's default permanent items are now created during object
   creation (this was previously done on-demand)

BUG=365774

Review URL: https://codereview.chromium.org/263723003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@268881 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 298 insertions, 60 deletions

diff --git a/sync/test/fake_server/bookmark_entity.h b/sync/test/fake_server/bookmark_entity.h
index 8c68a81..3f108ba 100644
--- a/sync/test/fake_server/bookmark_entity.h
+++ b/sync/test/fake_server/bookmark_entity.h
@@ -36,13 +36,6 @@ class BookmarkEntity : public FakeServerEntity {
       FakeServerEntity* current_server_entity,
       const std::string& parent_id);
 
-  // FakeServerEntity implementation.
-  virtual std::string GetParentId() const OVERRIDE;
-  virtual sync_pb::SyncEntity* SerializeAsProto() OVERRIDE;
-  virtual bool IsDeleted() const OVERRIDE;
-  virtual bool IsFolder() const OVERRIDE;
-
- private:
   BookmarkEntity(const std::string& id,
                  const syncer::ModelType& model_type,
                  int64 version,
@@ -56,6 +49,13 @@ class BookmarkEntity : public FakeServerEntity {
                  int64 creation_time,
                  int64 last_modified_time);
 
+  // FakeServerEntity implementation.
+  virtual std::string GetParentId() const OVERRIDE;
+  virtual sync_pb::SyncEntity* SerializeAsProto() OVERRIDE;
+  virtual bool IsDeleted() const OVERRIDE;
+  virtual bool IsFolder() const OVERRIDE;
+
+ private:
   // All member values have equivalent fields in SyncEntity.
   std::string originator_cache_guid_;
   std::string originator_client_item_id_;
diff --git a/sync/test/fake_server/bookmark_entity_builder.cc b/sync/test/fake_server/bookmark_entity_builder.cc
new file mode 100644
index 0000000..04e7e97
--- /dev/null
+++ b/sync/test/fake_server/bookmark_entity_builder.cc
@@ -0,0 +1,85 @@
+// 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/bookmark_entity_builder.h"
+
+#include <string>
+
+#include "base/guid.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
+#include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/base/unique_position.h"
+#include "sync/protocol/sync.pb.h"
+#include "sync/syncable/syncable_util.h"
+#include "sync/test/fake_server/bookmark_entity.h"
+#include "sync/test/fake_server/fake_server_entity.h"
+#include "sync/util/time.h"
+#include "url/gurl.h"
+
+using std::string;
+
+using syncer::ModelType;
+using syncer::syncable::GenerateSyncableBookmarkHash;
+
+// A version must be passed when creating a FakeServerEntity, but this value
+// is overrideen immediately when saving the entity in FakeServer.
+const int64 kUnusedVersion = 0L;
+
+// Default time (creation and last modified) used when creating entities.
+const int64 kDefaultTime = 1234L;
+
+namespace fake_server {
+
+BookmarkEntityBuilder::BookmarkEntityBuilder(
+    const string& title,
+    const GURL& url,
+    const string& originator_cache_guid,
+    const string& originator_client_item_id)
+    : EntityBuilder(syncer::BOOKMARKS, title),
+      url_(url),
+      originator_cache_guid_(originator_cache_guid),
+      originator_client_item_id_(originator_client_item_id) {
+}
+
+BookmarkEntityBuilder::~BookmarkEntityBuilder() {
+}
+
+scoped_ptr<FakeServerEntity> BookmarkEntityBuilder::Build() {
+  if (!url_.is_valid()) {
+    return make_scoped_ptr<FakeServerEntity>(NULL);
+  }
+
+  sync_pb::EntitySpecifics entity_specifics;
+  sync_pb::BookmarkSpecifics* bookmark_specifics =
+      entity_specifics.mutable_bookmark();
+  bookmark_specifics->set_title(name_);
+  bookmark_specifics->set_url(url_.spec());
+
+  sync_pb::UniquePosition unique_position;
+  // TODO(pvalenzuela): Allow caller customization of the position integer.
+  string suffix = GenerateSyncableBookmarkHash(originator_cache_guid_,
+                                               originator_client_item_id_);
+  syncer::UniquePosition::FromInt64(0, suffix).ToProto(&unique_position);
+
+  return make_scoped_ptr<FakeServerEntity>(
+      new BookmarkEntity(id_,
+                         model_type_,
+                         kUnusedVersion,
+                         name_,
+                         originator_cache_guid_,
+                         originator_client_item_id_,
+                         unique_position,
+                         entity_specifics,
+                         // TODO(pvalenzuela): Support bookmark folders.
+                         false,
+                         // TODO(pvalenzuela): Support caller specification of
+                         // the parent bookmark folder.
+                         FakeServerEntity::CreateId(syncer::BOOKMARKS,
+                                                    "bookmark_bar"),
+                         kDefaultTime,
+                         kDefaultTime));
+}
+
+}  // namespace fake_server
diff --git a/sync/test/fake_server/bookmark_entity_builder.h b/sync/test/fake_server/bookmark_entity_builder.h
new file mode 100644
index 0000000..e8275fa
--- /dev/null
+++ b/sync/test/fake_server/bookmark_entity_builder.h
@@ -0,0 +1,40 @@
+// 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.
+
+#ifndef SYNC_TEST_FAKE_SERVER_BOOKMARK_ENTITY_BUILDER_H_
+#define SYNC_TEST_FAKE_SERVER_BOOKMARK_ENTITY_BUILDER_H_
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "sync/internal_api/public/base/model_type.h"
+#include "sync/test/fake_server/entity_builder.h"
+#include "sync/test/fake_server/fake_server_entity.h"
+#include "url/gurl.h"
+
+namespace fake_server {
+
+// Builder for BookmarkEntity objects.
+class BookmarkEntityBuilder : public EntityBuilder {
+ public:
+  explicit BookmarkEntityBuilder(const std::string& title,
+                                 const GURL& url,
+                                 const std::string& originator_cache_guid,
+                                 const std::string& originator_client_item_id);
+
+  virtual ~BookmarkEntityBuilder();
+
+  // EntityBuilder
+  virtual scoped_ptr<FakeServerEntity> Build() OVERRIDE;
+
+ private:
+  // The bookmark's URL.
+  GURL url_;
+  std::string originator_cache_guid_;
+  std::string originator_client_item_id_;
+};
+
+}  // namespace fake_server
+
+#endif  // SYNC_TEST_FAKE_SERVER_BOOKMARK_ENTITY_BUILDER_H_
diff --git a/sync/test/fake_server/entity_builder.cc b/sync/test/fake_server/entity_builder.cc
new file mode 100644
index 0000000..c5e2acf
--- /dev/null
+++ b/sync/test/fake_server/entity_builder.cc
@@ -0,0 +1,27 @@
+// 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/entity_builder.h"
+
+#include <string>
+
+#include "base/guid.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+using std::string;
+
+using syncer::ModelType;
+
+namespace fake_server {
+
+EntityBuilder::EntityBuilder(ModelType model_type, const string& name)
+    : id_(FakeServerEntity::CreateId(model_type, base::GenerateGUID())),
+      model_type_(model_type),
+      name_(name) {
+}
+
+EntityBuilder::~EntityBuilder() {
+}
+
+}  // namespace fake_server
diff --git a/sync/test/fake_server/entity_builder.h b/sync/test/fake_server/entity_builder.h
new file mode 100644
index 0000000..adb3d10
--- /dev/null
+++ b/sync/test/fake_server/entity_builder.h
@@ -0,0 +1,37 @@
+// 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.
+
+#ifndef SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_H_
+#define SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_H_
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "sync/internal_api/public/base/model_type.h"
+#include "sync/test/fake_server/fake_server_entity.h"
+#include "url/gurl.h"
+
+namespace fake_server {
+
+// Parent class for FakeServerEntity builders.
+class EntityBuilder {
+ public:
+  virtual ~EntityBuilder();
+
+  // Builds a FakeServerEntity and returns a scoped_ptr tht owns it. If building
+  // was not successful, the returned scoped_ptr will not own a
+  // FakeServerEntity*.
+  virtual scoped_ptr<FakeServerEntity> Build() = 0;
+
+ protected:
+  EntityBuilder(syncer::ModelType model_type, const std::string& name);
+
+  std::string id_;
+  syncer::ModelType model_type_;
+  std::string name_;
+};
+
+}  // namespace fake_server
+
+#endif  // SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_H_
diff --git a/sync/test/fake_server/entity_builder_factory.cc b/sync/test/fake_server/entity_builder_factory.cc
new file mode 100644
index 0000000..a8f3d9e
--- /dev/null
+++ b/sync/test/fake_server/entity_builder_factory.cc
@@ -0,0 +1,39 @@
+// 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/entity_builder_factory.h"
+
+#include <string>
+
+#include "base/guid.h"
+#include "base/strings/string_number_conversions.h"
+#include "sync/test/fake_server/bookmark_entity_builder.h"
+#include "url/gurl.h"
+
+using std::string;
+
+namespace fake_server {
+
+EntityBuilderFactory::EntityBuilderFactory()
+    : cache_guid_(base::GenerateGUID()), latest_client_item_id_(0L)  {
+}
+
+EntityBuilderFactory::EntityBuilderFactory(const string& cache_guid)
+    : cache_guid_(cache_guid), latest_client_item_id_(0L) {
+}
+
+EntityBuilderFactory::~EntityBuilderFactory() {
+}
+
+BookmarkEntityBuilder EntityBuilderFactory::NewBookmarkEntityBuilder(
+    const string& title, const GURL& url) {
+  --latest_client_item_id_;
+  BookmarkEntityBuilder builder(title,
+                                url,
+                                cache_guid_,
+                                base::Int64ToString(latest_client_item_id_));
+  return builder;
+}
+
+}  // namespace fake_server
diff --git a/sync/test/fake_server/entity_builder_factory.h b/sync/test/fake_server/entity_builder_factory.h
new file mode 100644
index 0000000..f3b36f7
--- /dev/null
+++ b/sync/test/fake_server/entity_builder_factory.h
@@ -0,0 +1,37 @@
+// 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.
+
+#ifndef SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_FACTORY_H_
+#define SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_FACTORY_H_
+
+#include <string>
+
+#include "sync/test/fake_server/bookmark_entity_builder.h"
+#include "url/gurl.h"
+
+namespace fake_server {
+
+// Creates various types of EntityBuilders.
+//
+// add comment of why this class exists
+class EntityBuilderFactory {
+ public:
+  EntityBuilderFactory();
+  EntityBuilderFactory(const std::string& cache_guid);
+  virtual ~EntityBuilderFactory();
+
+  BookmarkEntityBuilder NewBookmarkEntityBuilder(const std::string& title,
+                                                 const GURL& url);
+ private:
+  // An identifier used when creating entities. This value is used similarly to
+  // the value in the Sync directory code.
+  std::string cache_guid_;
+
+  // The latest client item id assigned to an entity.
+  int64 latest_client_item_id_;
+};
+
+}  // namespace fake_server
+
+#endif  // SYNC_TEST_FAKE_SERVER_ENTITY_BUILDER_FACTORY_H_
diff --git a/sync/test/fake_server/fake_server.cc b/sync/test/fake_server/fake_server.cc
index 798797e..44bce54 100644
--- a/sync/test/fake_server/fake_server.cc
+++ b/sync/test/fake_server/fake_server.cc
@@ -97,21 +97,6 @@ class UpdateSieve {
     return min_version_;
   }
 
-  // Returns the data type IDs of types being synced for the first time.
-  vector<ModelType> GetFirstTimeTypes(
-      ModelTypeSet created_permanent_entity_types) const {
-    vector<ModelType> types;
-
-    ModelTypeToVersionMap::const_iterator it;
-    for (it = request_from_version_.begin(); it != request_from_version_.end();
-         ++it) {
-      if (it->second == 0 && !created_permanent_entity_types.Has(it->first))
-        types.push_back(it->first);
-    }
-
-    return types;
-  }
-
  private:
   typedef std::map<ModelType, int64> ModelTypeToVersionMap;
 
@@ -162,26 +147,17 @@ scoped_ptr<UpdateSieve> UpdateSieve::Create(
 
 FakeServer::FakeServer() : version_(0), birthday_(kDefaultBirthday) {
   keystore_keys_.push_back(kDefaultKeystoreKey);
+  CHECK(CreateDefaultPermanentItems());
 }
 
 FakeServer::~FakeServer() {
   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 }
 
-bool FakeServer::CreateDefaultPermanentItems(
-    const vector<ModelType>& first_time_types) {
-  for (vector<ModelType>::const_iterator it = first_time_types.begin();
-       it != first_time_types.end(); ++it) {
-    if (!ModelTypeSet::All().Has(*it)) {
-      NOTREACHED() << "An unexpected ModelType was encountered.";
-    }
-
-    ModelType model_type = *it;
-    if (created_permanent_entity_types_.Has(model_type)) {
-      // Do not create an entity for the type if it has already been created.
-      continue;
-    }
-
+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) {
@@ -210,8 +186,6 @@ bool FakeServer::CreateDefaultPermanentItems(
       }
       SaveEntity(other_bookmarks_entity);
     }
-
-    created_permanent_entity_types_.Put(model_type);
   }
 
   return true;
@@ -280,11 +254,7 @@ bool FakeServer::HandleGetUpdatesRequest(
   response->set_changes_remaining(0);
 
   scoped_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
-  vector<ModelType> first_time_types = sieve->GetFirstTimeTypes(
-      created_permanent_entity_types_);
-  if (!CreateDefaultPermanentItems(first_time_types)) {
-    return false;
-  }
+
   if (get_updates.create_mobile_bookmarks_folder() &&
       !CreateMobileBookmarksPermanentItem()) {
     return false;
@@ -496,6 +466,10 @@ scoped_ptr<base::DictionaryValue> FakeServer::GetEntitiesAsDictionaryValue() {
   return dictionary.Pass();
 }
 
+void FakeServer::InjectEntity(scoped_ptr<FakeServerEntity> entity) {
+  SaveEntity(entity.release());
+}
+
 void FakeServer::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
diff --git a/sync/test/fake_server/fake_server.h b/sync/test/fake_server/fake_server.h
index 6af77ab..8bb2c08 100644
--- a/sync/test/fake_server/fake_server.h
+++ b/sync/test/fake_server/fake_server.h
@@ -50,6 +50,11 @@ class FakeServer {
   // names.
   scoped_ptr<base::DictionaryValue> GetEntitiesAsDictionaryValue();
 
+  // Adds the FakeServerEntity* owned by |entity| to the server's collection
+  // of entities. This method makes no guarantees that the added entity will
+  // result in successful server operations.
+  void InjectEntity(scoped_ptr<FakeServerEntity> entity);
+
   // Adds |observer| to FakeServer's observer list. This should be called
   // before the Profile associated with |observer| is connected to the server.
   void AddObserver(Observer* observer);
@@ -69,9 +74,8 @@ class FakeServer {
   bool HandleCommitRequest(const sync_pb::CommitMessage& commit,
                            sync_pb::CommitResponse* response);
 
-  // Inserts the appropriate permanent items in |entities_|.
-  bool CreateDefaultPermanentItems(
-      const std::vector<syncer::ModelType>& first_time_types);
+  // Inserts the default permanent items in |entities_|.
+  bool CreateDefaultPermanentItems();
 
   // Inserts the mobile bookmarks folder entity in |entities_|.
   bool CreateMobileBookmarksPermanentItem();
@@ -118,11 +122,6 @@ class FakeServer {
   // All Keystore keys known to the server.
   std::vector<std::string> keystore_keys_;
 
-  // All ModelTypes for which permanent entities have been created. These types
-  // are kept track of so that permanent entities are not recreated for new
-  // clients.
-  syncer::ModelTypeSet created_permanent_entity_types_;
-
   // FakeServer's observers.
   ObserverList<Observer, true> observers_;
 };
diff --git a/sync/test/fake_server/fake_server_entity.h b/sync/test/fake_server/fake_server_entity.h
index dd2cc75..7f30bb0 100644
--- a/sync/test/fake_server/fake_server_entity.h
+++ b/sync/test/fake_server/fake_server_entity.h
@@ -17,6 +17,15 @@ namespace fake_server {
 // The representation of a Sync entity for the fake server.
 class FakeServerEntity {
  public:
+  // Creates an ID of the form <type><separator><inner-id> where
+  // <type> is the EntitySpecifics field number for |model_type|, <separator>
+  // is kIdSeparator, and <inner-id> is |inner_id|.
+  //
+  // If |inner_id| is globally unique, then the returned ID will also be
+  // globally unique.
+  static std::string CreateId(const syncer::ModelType& model_type,
+                              const std::string& inner_id);
+
   virtual ~FakeServerEntity();
   const std::string& GetId() const;
   syncer::ModelType GetModelType() const;
@@ -31,15 +40,6 @@ class FakeServerEntity {
   virtual bool IsFolder() const = 0;
 
  protected:
-  // Creates an ID of the form <type><separator><inner-id> where
-  // <type> is the EntitySpecifics field number for |model_type|, <separator>
-  // is kIdSeparator, and <inner-id> is |inner_id|.
-  //
-  // If |inner_id| is globally unique, then the returned ID will also be
-  // globally unique.
-  static std::string CreateId(const syncer::ModelType& model_type,
-                              const std::string& inner_id);
-
   // Extracts the ModelType from |id|. If |id| is malformed or does not contain
   // a valid ModelType, UNSPECIFIED is returned.
   static syncer::ModelType GetModelTypeFromId(const std::string& id);