[USS] Implement SharedModelTypeProcessor::GetAllNodes for USS

components/sync/api/entity_data.cc

 // Copyright 2015 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 "components/sync/api/entity_data.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "components/sync/base/unique_position.h"
+#include "components/sync/protocol/proto_value_conversions.h"
 
 namespace syncer_v2 {
 
+namespace {

[skym, 2016/09/12 16:40:38]

I don't think namespaces affect macros

[Gang Wu, 2016/09/12 22:38:02]

Done.

+#define ADD_TO_DICT(dict, name, value) \

[skym, 2016/09/12 16:40:38]

Why are you using a macro and not a function here?

[pavely, 2016/09/12 20:43:04]

When you use one-off macros like this it is better to define it right before the
function it is used in and then #undef it right after.

[Gang Wu, 2016/09/12 22:38:02]

Done.

[Gang Wu, 2016/09/12 22:38:03]

# can translate parameter to string, more general than write a function to
translate parameter to string.

+  dict->SetString(base::ToUpperASCII(#name), value);

[skym, 2016/09/12 16:40:38]

What does the # in "#name" do?

[maxbogue, 2016/09/12 17:44:26]

I think it extracts the text of the variable name...?

[Gang Wu, 2016/09/12 22:38:02]

#name can translate parameter name to string "name"

[Gang Wu, 2016/09/12 22:38:03]

yes.

+}

[skym, 2016/09/12 16:40:38]

  // namespace

[Gang Wu, 2016/09/12 22:38:02]

Done.

+
 EntityData::EntityData() {}
 EntityData::~EntityData() {}
 
 void EntityData::Swap(EntityData* other) {
   id.swap(other->id);
   client_tag_hash.swap(other->client_tag_hash);
   non_unique_name.swap(other->non_unique_name);
 
   specifics.Swap(&other->specifics);
 
   std::swap(creation_time, other->creation_time);
   std::swap(modification_time, other->modification_time);
 
   parent_id.swap(other->parent_id);
   unique_position.Swap(&other->unique_position);
 }
 
 EntityDataPtr EntityData::PassToPtr() {
   EntityDataPtr target;
   target.swap_value(this);
   return target;
 }
 
+// static
+std::unique_ptr<base::DictionaryValue> EntityData::ToValue(
+    const EntityData& entity_data) {
+  std::unique_ptr<base::DictionaryValue> dict =
+      syncer::EntitySpecificsToValue(entity_data.specifics);
+  ADD_TO_DICT(dict, id, entity_data.id);

[maxbogue, 2016/09/12 17:44:26]

Can you not just do dict->SetString("ID", entity_data.id)? That would be lot
clearer than this macro approach.

[pavely, 2016/09/12 20:43:04]

You have two patterns here: simple string fields and fields that require
nontrivial conversion. 
For string fields you can create macro SET_STRING_FIELD(dict, field). It would
look something like this:
#define SET_STRING_FIELD(dict, field) \
  dict->SetString(#field, field);

For other fields you can either call dict->SetString(...) directory or create
macro SET_FIELD_WITH_CONVERSION(dict, field, conv_fn) and call conversion
function from within.

There is a conversion function from base::Time to string:
https://cs.chromium.org/chromium/src/components/sync/base/time.h?q=syncer::Ge...

[Gang Wu, 2016/09/12 22:38:03]

Done.

[Gang Wu, 2016/09/12 22:38:03]

I copy this approach from proto_value_conversions.cc.
I do agree this macro approach is not clear, but for consistence, I used
proto_value_conversions approach, and even the naming standard(TOValue not
ToDictionaryValue). 

+  ADD_TO_DICT(dict, client_tag_hash, entity_data.client_tag_hash);
+  ADD_TO_DICT(dict, non_unique_name, entity_data.non_unique_name);
+  ADD_TO_DICT(dict, parent_id, entity_data.parent_id);
+  ADD_TO_DICT(dict, creation_time,
+              base::Int64ToString(entity_data.creation_time.ToInternalValue()));
+  ADD_TO_DICT(
+      dict, modification_time,
+      base::Int64ToString(entity_data.modification_time.ToInternalValue()));
+  ADD_TO_DICT(dict, unique_position,
+              syncer::UniquePosition::FromProto(entity_data.unique_position)
+                  .ToDebugString());
+  return dict;
+}
+
 void EntityDataTraits::SwapValue(EntityData* dest, EntityData* src) {
   dest->Swap(src);
 }
 
 bool EntityDataTraits::HasValue(const EntityData& value) {
   return !value.client_tag_hash.empty();
 }
 
 const EntityData& EntityDataTraits::DefaultValue() {
   CR_DEFINE_STATIC_LOCAL(EntityData, default_instance, ());
   return default_instance;
 }
 
 }  // namespace syncer_v2