Implement features needed for local ack handling in InvalidationStateTracker.

chrome/browser/sync/invalidations/invalidator_storage.cc

 // Copyright (c) 2012 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 "chrome/browser/sync/invalidations/invalidator_storage.h"
 
 #include "base/base64.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
+#include "base/task_runner.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/notifier/invalidation_util.h"
 
 using syncer::InvalidationStateMap;
 
 namespace browser_sync {
 
 namespace {
 
 const char kSourceKey[] = "source";
 const char kNameKey[] = "name";
 const char kMaxVersionKey[] = "max-version";
+const char kPayloadKey[] = "payload";
+const char kCurrentAckHandleKey[] = "current-ack";
+const char kExpectedAckHandleKey[] = "expected-ack";
 
 bool ValueToObjectIdAndState(const DictionaryValue& value,
                              invalidation::ObjectId* id,
                              syncer::InvalidationState* state) {
   std::string source_str;
-  int source = 0;
-  std::string name;
-  std::string max_version_str;
   if (!value.GetString(kSourceKey, &source_str)) {
     DLOG(WARNING) << "Unable to deserialize source";
     return false;
   }
+  int source = 0;
+  if (!base::StringToInt(source_str, &source)) {
+    DLOG(WARNING) << "Invalid source: " << source_str;
+    return false;
+  }
+  std::string name;
   if (!value.GetString(kNameKey, &name)) {
     DLOG(WARNING) << "Unable to deserialize name";
     return false;
   }
-  if (!value.GetString(kMaxVersionKey, &max_version_str)) {
-    DLOG(WARNING) << "Unable to deserialize max version";
-    return false;
+  // Fields that may not be set if we've only received an invalidation for an
+  // unknown version or for all types.
+  std::string max_version_str;
+  if (value.GetString(kMaxVersionKey, &max_version_str)) {

[akalin, 2012/11/28 00:11:42]

isn't kMaxVersionkey always present?  looks like it's always set in
ObjectIdAndStateToValue

[dcheng, 2012/11/30 01:42:54]

Hm. Yeah, you're right. I was thinking from the wrong perspective; clearly, by
the time it's persisted to disk, a version number will be present. Fixed.

+    if (!base::StringToInt64(max_version_str, &state->version)) {
+      DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str;
+      return false;
+    }
   }
-  if (!base::StringToInt(source_str, &source)) {
-    DLOG(WARNING) << "Invalid source: " << source_str;
-    return false;
+  value.GetString(kPayloadKey, &state->payload);
+  *id = invalidation::ObjectId(source, name);

[akalin, 2012/11/28 00:11:42]

move this closer to where source and name are set?  newline afterwards perhaps?

[dcheng, 2012/11/30 01:42:54]

I did this intentionally to avoid a state where the output arguments are "half"
initialized. But it doesn't matter.

+  // The ack handle fields won't be set if upgrading from previous versions of

[akalin, 2012/11/28 00:11:42]

clear state first?

[dcheng, 2012/11/30 01:42:54]

While this could be less error prone, it's also redundant (we pass in a default
constructed state which does all the initialization currently). I'm not sure of
a good way to defer that initialization here =/

[akalin, 2012/11/30 02:45:15]

i guess it's okay since this is a private function.

+  // Chrome.
+  const base::DictionaryValue* current_ack_handle_value = NULL;
+  if (value.GetDictionary(kCurrentAckHandleKey, &current_ack_handle_value)) {
+    state->current.ResetFromValue(*current_ack_handle_value);
   }
-  if (!base::StringToInt64(max_version_str, &state->version)) {
-    DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str;
-    return false;
+  // TODO(dcheng): Consider regenerating the latest ack handle value on Chrome

[akalin, 2012/11/28 00:11:42]

hmm i don't understand this comment.  what do you mean?

[dcheng, 2012/11/30 01:42:54]

One of my original ideas was to ignore the persist current/expected ack handle
values (other than comparing for equality), and then regenerate new ones. That
way, we can easily update the AckHandle serialization format if needed.

However, I'm not convinced this is needed so I've removed the comment.

+  // startup to allow for format changes?
+  const base::DictionaryValue* expected_ack_handle_value = NULL;
+  if (value.GetDictionary(kExpectedAckHandleKey, &expected_ack_handle_value)) {
+    state->expected.ResetFromValue(*expected_ack_handle_value);
+  } else {
+    // In this case, we should never have a valid current value set.
+    DCHECK(!state->current.IsValid());
+    state->current = syncer::AckHandle::InvalidAckHandle();
   }
-  *id = invalidation::ObjectId(source, name);
   return true;
 }
 
 // The caller owns the returned value.
 DictionaryValue* ObjectIdAndStateToValue(
     const invalidation::ObjectId& id, const syncer::InvalidationState& state) {
   DictionaryValue* value = new DictionaryValue;
   value->SetString(kSourceKey, base::IntToString(id.source()));
   value->SetString(kNameKey, id.name());
   value->SetString(kMaxVersionKey, base::Int64ToString(state.version));
+  value->SetString(kPayloadKey, state.payload);
+  if (state.current.IsValid())
+    value->Set(kCurrentAckHandleKey, state.current.ToValue().release());
+  if (state.expected.IsValid())
+    value->Set(kExpectedAckHandleKey, state.expected.ToValue().release());
   return value;
 }
 
 }  // namespace
 
 InvalidatorStorage::InvalidatorStorage(PrefService* pref_service)
     : pref_service_(pref_service) {
   // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case
   // throughout this file.  This is a problem now due to lack of injection at
   // ProfileSyncService. Bug 130176.
@@ skipping 17 matching lines @@
   if (!pref_service_) {
     return state_map;
   }
   const base::ListValue* state_map_list =
       pref_service_->GetList(prefs::kInvalidatorMaxInvalidationVersions);
   CHECK(state_map_list);
   DeserializeFromList(*state_map_list, &state_map);
   return state_map;
 }
 
-void InvalidatorStorage::SetMaxVersion(const invalidation::ObjectId& id,
-                                       int64 max_version) {
+void InvalidatorStorage::SetMaxVersionAndPayload(
+    const invalidation::ObjectId& id,
+    int64 max_version,
+    const std::string& payload) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(pref_service_);
   InvalidationStateMap state_map = GetAllInvalidationStates();
   InvalidationStateMap::iterator it = state_map.find(id);
   if ((it != state_map.end()) && (max_version <= it->second.version)) {
     NOTREACHED();
     return;
   }
   state_map[id].version = max_version;
+  state_map[id].payload = payload;
 
   base::ListValue state_map_list;
   SerializeToList(state_map, &state_map_list);
   pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
                      state_map_list);
 }
 
 void InvalidatorStorage::Forget(const syncer::ObjectIdSet& ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(pref_service_);
@@ skipping 119 matching lines @@
   base::Base64Decode(base64_data, &data);
   return data;
 }
 
 void InvalidatorStorage::Clear() {
   DCHECK(thread_checker_.CalledOnValidThread());
   pref_service_->ClearPref(prefs::kInvalidatorMaxInvalidationVersions);
   pref_service_->ClearPref(prefs::kInvalidatorInvalidationState);
 }
 
+void InvalidatorStorage::GenerateAckHandles(
+    const syncer::ObjectIdSet& ids,
+    const scoped_refptr<base::TaskRunner>& task_runner,
+    const base::Callback<void(const syncer::AckHandleMap&)> callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  CHECK(pref_service_);
+  InvalidationStateMap state_map = GetAllInvalidationStates();
+
+  syncer::AckHandleMap ack_handles;
+  for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
+       ++it) {
+    state_map[*it].expected = syncer::AckHandle::CreateUnique();
+    ack_handles.insert(std::make_pair(*it, state_map[*it].expected));
+  }
+
+  base::ListValue state_map_list;
+  SerializeToList(state_map, &state_map_list);
+  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
+                     state_map_list);
+
+  task_runner->PostTask(FROM_HERE, base::Bind(callback, ack_handles));

[akalin, 2012/11/28 00:11:42]

do something with return value?  maybe just ignore_result?

[dcheng, 2012/11/30 01:42:54]

Done.

+}
+
+void InvalidatorStorage::Acknowledge(const invalidation::ObjectId& id,
+                                     const syncer::AckHandle& ack_handle) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  CHECK(pref_service_);
+  InvalidationStateMap state_map = GetAllInvalidationStates();
+
+  InvalidationStateMap::iterator it = state_map.find(id);
+  // This could happen if the acknowledgement is delayed and Forget() has
+  // already been called.
+  if (it == state_map.end())
+    return;
+  it->second.current = ack_handle;
+
+  base::ListValue state_map_list;
+  SerializeToList(state_map, &state_map_list);
+  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
+                     state_map_list);
+}
+
 }  // namespace browser_sync