sync: Inject sync/'s dependency on invalidations

sync/tools/sync_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 <cstddef>
 #include <cstdio>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 #include "sync/internal_api/public/http_bridge.h"
 #include "sync/internal_api/public/internal_components_factory_impl.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/sync_manager.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_event_handler.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/test/fake_encryptor.h"
 #include "sync/tools/null_invalidation_state_tracker.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 // This is a simple utility that initializes a sync client and
 // prints out any events.
 
@@ skipping 122 matching lines @@
  public:
   virtual ~LoggingJsEventHandler() {}
 
   virtual void HandleJsEvent(
       const std::string& name,
       const JsEventDetails& details) OVERRIDE {
     VLOG(1) << name << ": " << details.ToString();
   }
 };
 
+class InvalidationAdapter : public syncer::InvalidationInterface {
+ public:
+  explicit InvalidationAdapter(const syncer::Invalidation& invalidation)
+      : invalidation_(invalidation) {}
+  virtual ~InvalidationAdapter() {}
+
+  virtual bool IsUnknownVersion() const OVERRIDE {
+    return invalidation_.is_unknown_version();
+  }
+
+  virtual const std::string& GetPayload() const OVERRIDE {
+    return invalidation_.payload();
+  }
+
+  virtual int64 GetVersion() const OVERRIDE {
+    return invalidation_.version();
+  }
+
+  virtual void Acknowledge() OVERRIDE {
+    invalidation_.Acknowledge();
+  }
+
+  virtual void Drop() OVERRIDE {
+    invalidation_.Drop();
+  }
+
+ private:
+  syncer::Invalidation invalidation_;
+};
+
+class InvalidatorShim : public InvalidationHandler {
+ public:
+  explicit InvalidatorShim(SyncManager* sync_manager)
+      : sync_manager_(sync_manager) {}
+
+  virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE {
+    sync_manager_->OnInvalidatorStateChange(state);
+  }
+
+  virtual void OnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE {
+    syncer::ObjectIdSet ids = invalidation_map.GetObjectIds();
+    for (syncer::ObjectIdSet::const_iterator ids_it = ids.begin();
+         ids_it != ids.end();
+         ++ids_it) {
+      syncer::ModelType type;
+      if (!NotificationTypeToRealModelType(ids_it->name(), &type)) {
+        DLOG(WARNING) << "Notification has invalid id: "
+                      << syncer::ObjectIdToString(*ids_it);
+      } else {
+        syncer::SingleObjectInvalidationSet invalidation_set =
+            invalidation_map.ForObject(*ids_it);
+        for (syncer::SingleObjectInvalidationSet::const_iterator inv_it =
+                 invalidation_set.begin();
+             inv_it != invalidation_set.end();
+             ++inv_it) {
+          scoped_ptr<syncer::InvalidationInterface> inv_adapter(
+              new InvalidationAdapter(*inv_it));
+          sync_manager_->OnIncomingInvalidation(type, inv_adapter.Pass());
+        }
+      }
+    }
+  }
+
+  virtual std::string GetOwnerName() const OVERRIDE {
+    return "InvalidatorShim";
+  }
+
+ private:
+  SyncManager* sync_manager_;
+};
+
 void LogUnrecoverableErrorContext() {
   base::debug::StackTrace().Print();
 }
 
 notifier::NotifierOptions ParseNotifierOptions(
     const CommandLine& command_line,
     const scoped_refptr<net::URLRequestContextGetter>&
         request_context_getter) {
   notifier::NotifierOptions notifier_options;
   notifier_options.request_context_getter = request_context_getter;
@@ skipping 176 matching lines @@
                     kRestoredKeystoreKeyForBootstrapping,
                     new InternalComponentsFactoryImpl(factory_switches),
                     &null_encryptor,
                     scoped_ptr<UnrecoverableErrorHandler>(
                         new LoggingUnrecoverableErrorHandler).Pass(),
                     &LogUnrecoverableErrorContext,
                     &scm_cancelation_signal);
   // TODO(akalin): Avoid passing in model parameters multiple times by
   // organizing handling of model types.
   invalidator->UpdateCredentials(credentials.email, credentials.sync_token);
-  invalidator->RegisterHandler(sync_manager.get());
+  scoped_ptr<InvalidatorShim> shim(new InvalidatorShim(sync_manager.get()));
+  invalidator->RegisterHandler(shim.get());
   invalidator->UpdateRegisteredIds(
-      sync_manager.get(), ModelTypeSetToObjectIdSet(model_types));
+      shim.get(), ModelTypeSetToObjectIdSet(model_types));
   sync_manager->StartSyncingNormally(routing_info);
 
   sync_loop.Run();
 
   io_thread.Stop();
   return 0;
 }
 
 }  // namespace
 }  // namespace syncer
 
 int main(int argc, char* argv[]) {
   return syncer::SyncClientMain(argc, argv);
 }