Separate sync and invalidation client IDs

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"
@@ skipping 86 matching lines @@
     : 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.
   if (pref_service_) {
     pref_service_->RegisterListPref(prefs::kInvalidatorMaxInvalidationVersions,
                                     PrefServiceSyncable::UNSYNCABLE_PREF);
     pref_service_->RegisterStringPref(prefs::kInvalidatorInvalidationState,
                                       std::string(),
                                       PrefServiceSyncable::UNSYNCABLE_PREF);
+    pref_service_->RegisterStringPref(prefs::kInvalidatorInvalidatorClientId,
+                                      std::string(),
+                                      PrefServiceSyncable::UNSYNCABLE_PREF);
 
     MigrateMaxInvalidationVersionsPref();
   }
 }
 
 InvalidatorStorage::~InvalidatorStorage() {
 }
 
 InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 132 matching lines @@
     }
     invalidation::ObjectId id;
     if (!syncer::RealModelTypeToObjectId(model_type, &id)) {
       DLOG(WARNING) << "Invalid model type: " << model_type;
       continue;
     }
     (*map)[id].version = max_version;
   }
 }
 
+void InvalidatorStorage::SetInvalidatorClientId(const std::string& client_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  pref_service_->SetString(prefs::kInvalidatorInvalidatorClientId, client_id);
+}
+
+std::string InvalidatorStorage::GetInvalidatorClientId() const {
+  return pref_service_ ?
+      pref_service_->GetString(prefs::kInvalidatorInvalidatorClientId) : "";
+}
+
 void InvalidatorStorage::SetBootstrapData(const std::string& data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::string base64_data;
   base::Base64Encode(data, &base64_data);
   pref_service_->SetString(prefs::kInvalidatorInvalidationState,
                            base64_data);
 }
 
 std::string InvalidatorStorage::GetBootstrapData() const {
   std::string base64_data(pref_service_ ?
       pref_service_->GetString(prefs::kInvalidatorInvalidationState) : "");
   std::string data;
   base::Base64Decode(base64_data, &data);
   return data;
 }
 
 void InvalidatorStorage::Clear() {
   DCHECK(thread_checker_.CalledOnValidThread());
   pref_service_->ClearPref(prefs::kInvalidatorMaxInvalidationVersions);
+  pref_service_->ClearPref(prefs::kInvalidatorInvalidatorClientId);
   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();
@@ skipping 27 matching lines @@
     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