chrome/browser/invalidation/fake_invalidation_service.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/invalidation/fake_invalidation_service.h"
   6
   7 #include "base/callback.h"
   8 #include "base/macros.h"
   9 #include "components/invalidation/invalidation_service_util.h"
  10 #include "components/invalidation/object_id_invalidation_map.h"
  11
  12 namespace invalidation {
  13
  14 FakeInvalidationService::FakeInvalidationService()
  15     : client_id_(GenerateInvalidatorClientId()),
  16       identity_provider_(&token_service_) {
  17   invalidator_registrar_.UpdateInvalidatorState(syncer::INVALIDATIONS_ENABLED);
  18   token_service_.set_auto_post_fetch_response_on_message_loop(true);
  19 }
  20
  21 FakeInvalidationService::~FakeInvalidationService() {
  22 }
  23
  24 void FakeInvalidationService::RegisterInvalidationHandler(
  25       syncer::InvalidationHandler* handler) {
  26   invalidator_registrar_.RegisterHandler(handler);
  27 }
  28
  29 bool FakeInvalidationService::UpdateRegisteredInvalidationIds(
  30     syncer::InvalidationHandler* handler,
  31     const syncer::ObjectIdSet& ids) {
  32   return invalidator_registrar_.UpdateRegisteredIds(handler, ids);
  33 }
  34
  35 void FakeInvalidationService::UnregisterInvalidationHandler(
  36       syncer::InvalidationHandler* handler) {
  37   invalidator_registrar_.UnregisterHandler(handler);
  38 }
  39
  40 syncer::InvalidatorState FakeInvalidationService::GetInvalidatorState() const {
  41   return invalidator_registrar_.GetInvalidatorState();
  42 }
  43
  44 std::string FakeInvalidationService::GetInvalidatorClientId() const {
  45   return client_id_;
  46 }
  47
  48 InvalidationLogger* FakeInvalidationService::GetInvalidationLogger() {
  49   return NULL;
  50 }
  51
  52 void FakeInvalidationService::RequestDetailedStatus(
  53     base::Callback<void(const base::DictionaryValue&)> caller) const {
  54   base::DictionaryValue value;
  55   caller.Run(value);
  56 }
  57
  58 IdentityProvider* FakeInvalidationService::GetIdentityProvider() {
  59   return &identity_provider_;
  60 }
  61
  62 void FakeInvalidationService::SetInvalidatorState(
  63     syncer::InvalidatorState state) {
  64   invalidator_registrar_.UpdateInvalidatorState(state);
  65 }
  66
  67 void FakeInvalidationService::EmitInvalidationForTest(
  68     const syncer::Invalidation& invalidation) {
  69   // This function might need to modify the invalidator, so we start by making
  70   // an identical copy of it.
  71   syncer::Invalidation invalidation_copy(invalidation);
  72
  73   // If no one is listening to this invalidation, do not send it out.
  74   syncer::ObjectIdSet registered_ids =
  75       invalidator_registrar_.GetAllRegisteredIds();
  76   if (registered_ids.find(invalidation.object_id()) == registered_ids.end()) {
  77     mock_ack_handler_.RegisterUnsentInvalidation(&invalidation_copy);
  78     return;
  79   }
  80
  81   // Otherwise, register the invalidation with the mock_ack_handler_ and deliver
  82   // it to the appropriate consumer.
  83   mock_ack_handler_.RegisterInvalidation(&invalidation_copy);
  84   syncer::ObjectIdInvalidationMap invalidation_map;
  85   invalidation_map.Insert(invalidation_copy);
  86   invalidator_registrar_.DispatchInvalidationsToHandlers(invalidation_map);
  87 }
  88
  89 syncer::MockAckHandler* FakeInvalidationService::GetMockAckHandler() {
  90   return &mock_ack_handler_;
  91 }
  92
  93 }  // namespace invalidation