Sync FakeServer cleanup: CHECKs and logging info

sync/test/fake_server/permanent_entity.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/permanent_entity.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 
 namespace fake_server {
 
 PermanentEntity::~PermanentEntity() { }
 
 // static
 FakeServerEntity* PermanentEntity::Create(const ModelType& model_type,
                                           const string& server_tag,
                                           const string& name,
                                           const string& parent_server_tag) {
-  DCHECK(model_type != syncer::UNSPECIFIED);
-  DCHECK(!server_tag.empty());
-  DCHECK(!name.empty());
-  DCHECK(!parent_server_tag.empty());
-  if (parent_server_tag == kRootParentTag) {
-    return NULL;
-  }
+  CHECK(model_type != syncer::UNSPECIFIED) << "The entity's ModelType is "
+                                           << "invalid.";
+  CHECK(!server_tag.empty()) << "A PermanentEntity must have a server tag.";
+  CHECK(!name.empty()) << "The entity must have a non-empty name.";
+  CHECK(!parent_server_tag.empty()) << "A PermanentEntity must have a parent "
+                                    << "server tag.";
+  CHECK(parent_server_tag != kRootParentTag) << "Top-level entities should not "
+                                             << "be created with this factory.";
 
   string id = FakeServerEntity::CreateId(model_type, server_tag);
   string parent_id = FakeServerEntity::CreateId(model_type, parent_server_tag);
   sync_pb::EntitySpecifics entity_specifics;
   AddDefaultFieldValue(model_type, &entity_specifics);
   return new PermanentEntity(id,
                              model_type,
                              name,
                              parent_id,
                              server_tag,
                              entity_specifics);
 }
 
 // static
-FakeServerEntity* PermanentEntity::CreateTopLevel(
-    const ModelType& model_type) {
+FakeServerEntity* PermanentEntity::CreateTopLevel(const ModelType& model_type) {
+  CHECK(model_type != syncer::UNSPECIFIED) << "The entity's ModelType is "
+                                           << "invalid.";
   string server_tag = syncer::ModelTypeToRootTag(model_type);
   string name = syncer::ModelTypeToString(model_type);
   string id = FakeServerEntity::CreateId(model_type, server_tag);
   sync_pb::EntitySpecifics entity_specifics;
   AddDefaultFieldValue(model_type, &entity_specifics);
   return new PermanentEntity(id,
                              model_type,
                              name,
                              kRootParentTag,
                              server_tag,
                              entity_specifics);
 }
 
 // static
 FakeServerEntity* PermanentEntity::CreateUpdatedNigoriEntity(
     const sync_pb::SyncEntity& client_entity,
     FakeServerEntity* current_server_entity) {
   ModelType model_type = current_server_entity->GetModelType();
-  if (model_type != syncer::NIGORI) {
-    return NULL;
-  }
+  CHECK(model_type == syncer::NIGORI) << "This factory only supports NIGORI "
+                                      << "entities.";
 
   return new PermanentEntity(current_server_entity->GetId(),
                              model_type,
                              current_server_entity->GetName(),
                              current_server_entity->GetParentId(),
                              syncer::ModelTypeToRootTag(model_type),
                              client_entity.specifics());
 }
 
 PermanentEntity::PermanentEntity(const string& id,
@@ skipping 26 matching lines @@
 
 bool PermanentEntity::IsDeleted() const {
   return false;
 }
 
 bool PermanentEntity::IsFolder() const {
   return true;
 }
 
 }  // namespace fake_server