sync: migrate invalidation state from syncable::Directory to InvalidationStorage

sync/notifier/chrome_invalidation_client.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 "sync/notifier/chrome_invalidation_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 14 matching lines @@
 
 }  // anonymous namespace
 
 namespace sync_notifier {
 
 ChromeInvalidationClient::Listener::~Listener() {}
 
 ChromeInvalidationClient::ChromeInvalidationClient()
     : chrome_system_resources_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       listener_(NULL),
-      state_writer_(NULL),
       ticl_ready_(false) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
 }
 
 ChromeInvalidationClient::~ChromeInvalidationClient() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   Stop();
   DCHECK(!listener_);
-  DCHECK(!state_writer_);
 }
 
 void ChromeInvalidationClient::Start(
     const std::string& client_id, const std::string& client_info,
     const std::string& state,
     const InvalidationVersionMap& initial_max_invalidation_versions,
     const browser_sync::WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
     Listener* listener,
-    StateWriter* state_writer,
     base::WeakPtr<buzz::XmppTaskParentInterface> base_task) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   Stop();
 
   chrome_system_resources_.set_platform(client_info);
   chrome_system_resources_.Start();
 
   // The Storage resource is implemented as a write-through cache.  We populate
   // it with the initial state on startup, so subsequent writes go to disk and
   // update the in-memory cache, while reads just return the cached state.
@@ skipping 10 matching lines @@
                << syncable::ModelTypeToString(it->first) << " is "
                << it->second;
     }
   }
   invalidation_state_tracker_ = invalidation_state_tracker;
   DCHECK(invalidation_state_tracker_.IsInitialized());
 
   DCHECK(!listener_);
   DCHECK(listener);
   listener_ = listener;
-  DCHECK(!state_writer_);
-  DCHECK(state_writer);
-  state_writer_ = state_writer;
 
   int client_type = ipc::invalidation::ClientType::CHROME_SYNC;
   invalidation_client_.reset(
       invalidation::CreateInvalidationClient(
           &chrome_system_resources_, client_type, client_id,
           kApplicationName, this));
   ChangeBaseTask(base_task);
   invalidation_client_->Start();
 
   registration_manager_.reset(
@@ skipping 16 matching lines @@
     DCHECK(!cache_invalidation_packet_handler_.get());
     return;
   }
 
   registration_manager_.reset();
   cache_invalidation_packet_handler_.reset();
   chrome_system_resources_.Stop();
   invalidation_client_->Stop();
 
   invalidation_client_.reset();
-  state_writer_ = NULL;
   listener_ = NULL;
 
   invalidation_state_tracker_.Reset();
   max_invalidation_versions_.clear();
 }
 
 void ChromeInvalidationClient::RegisterTypes(syncable::ModelTypeSet types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   registered_types_ = types;
   if (ticl_ready_ && registration_manager_.get()) {
@@ skipping 164 matching lines @@
 void ChromeInvalidationClient::InformError(
     invalidation::InvalidationClient* client,
     const invalidation::ErrorInfo& error_info) {
   listener_->OnSessionStatusChanged(false);
   LOG(ERROR) << "Invalidation client encountered an error";
   // TODO(ghc): handle the error.
 }
 
 void ChromeInvalidationClient::WriteState(const std::string& state) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
-  CHECK(state_writer_);
-  state_writer_->WriteState(state);
+  DVLOG(1) << "WriteState";
+  invalidation_state_tracker_.Call(
+      FROM_HERE, &InvalidationStateTracker::SetInvalidationState, state);
 }
 
 }  // namespace sync_notifier