Home | History | Annotate | Download | only in notifier 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "sync/notifier/object_id_invalidation_map.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/compiler_specific.h"
     10 #include "base/values.h"
     11 
     12 namespace syncer {
     13 
     14 ObjectIdSet ObjectIdInvalidationMapToSet(
     15     const ObjectIdInvalidationMap& invalidation_map) {
     16   ObjectIdSet ids;
     17   for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
     18        it != invalidation_map.end(); ++it) {
     19     ids.insert(it->first);
     20   }
     21   return ids;
     22 }
     23 
     24 ObjectIdInvalidationMap ObjectIdSetToInvalidationMap(
     25     const ObjectIdSet& ids, int64 version, const std::string& payload) {
     26   ObjectIdInvalidationMap invalidation_map;
     27   for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
     28     // TODO(dcheng): Do we need to provide a way to set AckHandle?
     29     invalidation_map[*it].version = version;
     30     invalidation_map[*it].payload = payload;
     31   }
     32   return invalidation_map;
     33 }
     34 
     35 namespace {
     36 
     37 struct ObjectIdInvalidationMapValueEquals {
     38   bool operator()(const ObjectIdInvalidationMap::value_type& value1,
     39                   const ObjectIdInvalidationMap::value_type& value2) const {
     40     return
     41         (value1.first == value2.first) &&
     42         value1.second.Equals(value2.second);
     43   }
     44 };
     45 
     46 }  // namespace
     47 
     48 bool ObjectIdInvalidationMapEquals(
     49     const ObjectIdInvalidationMap& invalidation_map1,
     50     const ObjectIdInvalidationMap& invalidation_map2) {
     51   return
     52       (invalidation_map1.size() == invalidation_map2.size()) &&
     53       std::equal(invalidation_map1.begin(), invalidation_map1.end(),
     54                  invalidation_map2.begin(),
     55                  ObjectIdInvalidationMapValueEquals());
     56 }
     57 
     58 scoped_ptr<base::ListValue> ObjectIdInvalidationMapToValue(
     59     const ObjectIdInvalidationMap& invalidation_map) {
     60   scoped_ptr<base::ListValue> value(new base::ListValue());
     61   for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
     62        it != invalidation_map.end(); ++it) {
     63     base::DictionaryValue* entry = new base::DictionaryValue();
     64     entry->Set("objectId", ObjectIdToValue(it->first).release());
     65     entry->Set("state", it->second.ToValue().release());
     66     value->Append(entry);
     67   }
     68   return value.Pass();
     69 }
     70 
     71 bool ObjectIdInvalidationMapFromValue(const base::ListValue& value,
     72                                ObjectIdInvalidationMap* out) {
     73   out->clear();
     74   for (base::ListValue::const_iterator it = value.begin();
     75        it != value.end(); ++it) {
     76     const base::DictionaryValue* entry = NULL;
     77     const base::DictionaryValue* id_value = NULL;
     78     const base::DictionaryValue* invalidation_value = NULL;
     79     invalidation::ObjectId id;
     80     Invalidation invalidation;
     81     if (!(*it)->GetAsDictionary(&entry) ||
     82         !entry->GetDictionary("objectId", &id_value) ||
     83         !entry->GetDictionary("state", &invalidation_value) ||
     84         !ObjectIdFromValue(*id_value, &id) ||
     85         !invalidation.ResetFromValue(*invalidation_value)) {
     86       return false;
     87     }
     88     ignore_result(out->insert(std::make_pair(id, invalidation)));
     89   }
     90   return true;
     91 }
     92 
     93 ModelTypeInvalidationMap ObjectIdInvalidationMapToModelTypeInvalidationMap(
     94     const ObjectIdInvalidationMap& invalidation_map) {
     95   ModelTypeInvalidationMap type_invalidation_map;
     96   for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
     97        it != invalidation_map.end(); ++it) {
     98     ModelType model_type;
     99     if (!ObjectIdToRealModelType(it->first, &model_type)) {
    100       DLOG(WARNING) << "Invalid object ID: "
    101                     << ObjectIdToString(it->first);
    102       continue;
    103     }
    104     type_invalidation_map[model_type] = it->second;
    105   }
    106   return type_invalidation_map;
    107 }
    108 
    109 ObjectIdInvalidationMap ModelTypeInvalidationMapToObjectIdInvalidationMap(
    110     const ModelTypeInvalidationMap& invalidation_map) {
    111   ObjectIdInvalidationMap id_invalidation_map;
    112   for (ModelTypeInvalidationMap::const_iterator it = invalidation_map.begin();
    113        it != invalidation_map.end(); ++it) {
    114     invalidation::ObjectId id;
    115     if (!RealModelTypeToObjectId(it->first, &id)) {
    116       DLOG(WARNING) << "Invalid model type " << it->first;
    117       continue;
    118     }
    119     id_invalidation_map[id] = it->second;
    120   }
    121   return id_invalidation_map;
    122 }
    123 
    124 }  // namespace syncer
    125