sync: don't allow NULL profile in ProfileSyncService and friends

chrome/browser/invalidation/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/invalidation/invalidator_storage.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 96 matching lines @@
       prefs::kInvalidatorClientId,
       std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       prefs::kSyncMaxInvalidationVersions,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 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.
-  if (pref_service_)
-    MigrateMaxInvalidationVersionsPref();
+  DCHECK(pref_service);
+  MigrateMaxInvalidationVersionsPref();
 }
 
 InvalidatorStorage::~InvalidatorStorage() {
 }
 
 InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   InvalidationStateMap state_map;
-  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::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_);
   InvalidationStateMap state_map = GetAllInvalidationStates();
   for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
        ++it) {
     state_map.erase(*it);
   }
 
   base::ListValue state_map_list;
   SerializeToList(state_map, &state_map_list);
   pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
                      state_map_list);
@@ skipping 91 matching lines @@
   }
 }
 
 void InvalidatorStorage::SetInvalidatorClientId(const std::string& client_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Clear();  // We can't reuse our old invalidation state if the ID changes.
   pref_service_->SetString(prefs::kInvalidatorClientId, client_id);
 }
 
 std::string InvalidatorStorage::GetInvalidatorClientId() const {
-  return pref_service_ ?
-      pref_service_->GetString(prefs::kInvalidatorClientId) :
-          std::string();
+  return pref_service_->GetString(prefs::kInvalidatorClientId);
 }
 
 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());
+      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::kInvalidatorClientId);
   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,
                                       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 invalidation