Commit InvalidationService implementations

chrome/browser/invalidation/android_invalidation_service.cc

+// Copyright (c) 2013 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/android_invalidation_service.h"
+
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_service.h"
+
+namespace invalidation {
+
+AndroidInvalidationService::AndroidInvalidationService()
+    : invalidator_state_(syncer::INVALIDATIONS_ENABLED) { }
+
+AndroidInvalidationService::~AndroidInvalidationService() { }
+
+void AndroidInvalidationService::Init(Profile* profile) {
+  DCHECK(CalledOnValidThread());
+  registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
+                 content::Source<Profile>(profile));
+}
+
+void AndroidInvalidationService::RegisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  DCHECK(CalledOnValidThread());
+  invalidator_registrar_.RegisterHandler(handler);
+}
+
+void AndroidInvalidationService::UpdateRegisteredInvalidationIds(
+    syncer::InvalidationHandler* handler,
+    const syncer::ObjectIdSet& ids) {
+  DCHECK(CalledOnValidThread());
+  invalidator_registrar_.UpdateRegisteredIds(handler, ids);
+}
+
+void AndroidInvalidationService::UnregisterInvalidationHandler(
+    syncer::InvalidationHandler* handler) {
+  DCHECK(CalledOnValidThread());
+  invalidator_registrar_.UnregisterHandler(handler);
+}
+
+void AndroidInvalidationService::AcknowledgeInvalidation(
+    const invalidation::ObjectId& id,
+    const syncer::AckHandle& ack_handle) {
+  DCHECK(CalledOnValidThread());
+  // Do nothing.  The Android invalidator does not support ack tracking.
+}
+
+syncer::InvalidatorState
+AndroidInvalidationService::GetInvalidatorState() const {
+  DCHECK(CalledOnValidThread());
+  return invalidator_state_;
+}
+
+std::string AndroidInvalidationService::GetInvalidatorClientId() const {
+  DCHECK(CalledOnValidThread());
+  // TODO: Return a valid ID here.  See crbug.com/172391.
+  return "Bogus";
+}
+
+void AndroidInvalidationService::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(type, chrome::NOTIFICATION_SYNC_REFRESH_REMOTE);
+
+  // TODO(akalin): Use ObjectIdInvalidationMap here instead.  We'll have to
+  // make sure all emitters of the relevant notifications also use
+  // ObjectIdInvalidationMap.
+  content::Details<const syncer::ModelTypeInvalidationMap>
+      state_details(details);
+  const syncer::ModelTypeInvalidationMap& model_type_invalidation_map =
+      *(state_details.ptr());
+  syncer::ObjectIdInvalidationMap object_invalidation_map =
+      ModelTypeInvalidationMapToObjectIdInvalidationMap(
+          model_type_invalidation_map);
+
+  // An empty map implies that we should invalidate all.
+  const syncer::ObjectIdInvalidationMap& effective_invalidation_map =
+      object_invalidation_map.empty() ?
+      ObjectIdSetToInvalidationMap(
+          invalidator_registrar_.GetAllRegisteredIds(), std::string()) :
+      object_invalidation_map;
+
+  invalidator_registrar_.DispatchInvalidationsToHandlers(
+      effective_invalidation_map);
+}
+
+void AndroidInvalidationService::TriggerStateChangeForTest(
+    syncer::InvalidatorState state) {
+  DCHECK(CalledOnValidThread());
+  invalidator_state_ = state;
+  invalidator_registrar_.UpdateInvalidatorState(invalidator_state_);
+}
+
+} //  namespace invalidation