1// Copyright 2014 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#ifndef COMPONENTS_INVALIDATION_INVALIDATION_LOGGER_H_
6#define COMPONENTS_INVALIDATION_INVALIDATION_LOGGER_H_
7
8#include <map>
9#include <set>
10
11#include "base/memory/scoped_ptr.h"
12#include "base/observer_list.h"
13#include "components/invalidation/invalidation_util.h"
14#include "components/invalidation/invalidator_state.h"
15
16namespace base {
17class DictionaryValue;
18}  // namespace base
19
20namespace syncer {
21class InvalidationHandler;
22class ObjectIdInvalidationMap;
23}  // namespace syncer
24
25namespace invalidation {
26
27class InvalidationLoggerObserver;
28
29// This class is in charge of logging invalidation-related information.
30// It is used store the state of the InvalidatorService that owns this object
31// and then rebroadcast it to observers than can display it accordingly
32// (like a debugging page). This class only stores lightweight state, as in
33// which services are registered and listening for certain objects, and the
34// status of the InvalidatorService (in order not to increase unnecesary
35// memory usage).
36//
37// Observers can be registered and will be called to be notified of any
38// status change immediatly. They can log there the history of what messages
39// they receive.
40
41class InvalidationLogger {
42
43 public:
44  InvalidationLogger();
45  ~InvalidationLogger();
46
47  // Pass through to any registered InvalidationLoggerObservers.
48  // We will do local logging here too.
49  void OnRegistration(const std::string& details);
50  void OnUnregistration(const std::string& details);
51  void OnStateChange(const syncer::InvalidatorState& new_state);
52  void OnUpdateIds(std::map<std::string, syncer::ObjectIdSet> updated_ids);
53  void OnDebugMessage(const base::DictionaryValue& details);
54  void OnInvalidation(const syncer::ObjectIdInvalidationMap& details);
55
56  // Triggers messages to be sent to the Observers to provide them with
57  // the current state of the logging.
58  void EmitContent();
59
60  // Add and remove observers listening for messages.
61  void RegisterObserver(InvalidationLoggerObserver* debug_observer);
62  void UnregisterObserver(InvalidationLoggerObserver* debug_observer);
63  bool IsObserverRegistered(InvalidationLoggerObserver* debug_observer);
64
65 private:
66  // Send to every Observer a OnStateChange event with the latest state.
67  void EmitState();
68
69  // Send to every Observer many OnUpdateIds events, each with one registrar
70  // and every objectId it currently has registered.
71  void EmitUpdatedIds();
72
73  // Send to every Observer a vector with the all the current registered
74  // handlers.
75  void EmitRegisteredHandlers();
76
77  // The list of every observer currently listening for notifications.
78  ObserverList<InvalidationLoggerObserver> observer_list_;
79
80  // The last InvalidatorState updated by the InvalidatorService.
81  syncer::InvalidatorState last_invalidator_state_;
82  base::Time last_invalidator_state_timestamp_;
83
84  // The map that contains every object id that is currently registered
85  // and its owner.
86  std::map<std::string, syncer::ObjectIdSet> latest_ids_;
87
88  // The map that counts how many invalidations per objectId there has been.
89  syncer::ObjectIdCountMap invalidation_count_;
90
91  // The name of all invalidatorHandler registered (note that this is not
92  // necessarily the same as the keys of latest_ids_, because they might
93  // have not registered any object id).
94  std::multiset<std::string> registered_handlers_;
95
96  DISALLOW_COPY_AND_ASSIGN(InvalidationLogger);
97};
98
99}  // namespace invalidation
100
101#endif  // COMPONENTS_INVALIDATION_INVALIDATION_LOGGER_H_
102