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"
 
 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;
   }
+  *id = invalidation::ObjectId(source, name);
+  std::string max_version_str;
   if (!value.GetString(kMaxVersionKey, &max_version_str)) {
     DLOG(WARNING) << "Unable to deserialize max version";
     return false;
   }
-  if (!base::StringToInt(source_str, &source)) {
-    DLOG(WARNING) << "Invalid source: " << source_str;
-    return false;
-  }
   if (!base::StringToInt64(max_version_str, &state->version)) {
     DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str;
     return false;
   }
-  *id = invalidation::ObjectId(source, name);
+  value.GetString(kPayloadKey, &state->payload);
+  // The ack handle fields won't be set if upgrading from previous versions of
+  // Chrome.
+  const base::DictionaryValue* current_ack_handle_value = NULL;
+  if (value.GetDictionary(kCurrentAckHandleKey, &current_ack_handle_value)) {
+    state->current.ResetFromValue(*current_ack_handle_value);
+  }
+  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();
+  }
   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);
+
+  ignore_result(task_runner->PostTask(FROM_HERE,

[akalin, 2012/11/30 02:53:02]

compiler_specific.h for ignore_result

[dcheng, 2012/11/30 23:44:54]

This is defined in basictypes.h.

+                                      base::Bind(callback, ack_handles)));
+}
+
+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