blob: efdf89d5d09b4f395859812e187ab055c8c80e8b (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
// Copyright 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.
//
// An implementation of SyncNotifier that wraps InvalidationNotifier
// on its own thread.
#ifndef SYNC_NOTIFIER_NON_BLOCKING_INVALIDATOR_H_
#define SYNC_NOTIFIER_NON_BLOCKING_INVALIDATOR_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "jingle/notifier/base/notifier_options.h"
#include "sync/base/sync_export.h"
#include "sync/notifier/invalidation_state_tracker.h"
#include "sync/notifier/invalidator.h"
#include "sync/notifier/invalidator_registrar.h"
#include "sync/notifier/invalidator_state.h"
#include "sync/notifier/unacked_invalidation_set.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace syncer {
class SyncNetworkChannel;
class GCMNetworkChannelDelegate;
// Callback type for function that creates SyncNetworkChannel. This function
// gets passed into NonBlockingInvalidator constructor.
typedef base::Callback<scoped_ptr<SyncNetworkChannel>(void)>
NetworkChannelCreator;
class SYNC_EXPORT_PRIVATE NonBlockingInvalidator
: public Invalidator,
public InvalidationStateTracker {
public:
// |invalidation_state_tracker| must be initialized and must outlive |this|.
NonBlockingInvalidator(
NetworkChannelCreator network_channel_creator,
const std::string& invalidator_client_id,
const UnackedInvalidationsMap& saved_invalidations,
const std::string& invalidation_bootstrap_data,
InvalidationStateTracker* invalidation_state_tracker,
const std::string& client_info,
const scoped_refptr<net::URLRequestContextGetter>&
request_context_getter);
virtual ~NonBlockingInvalidator();
// Invalidator implementation.
virtual void RegisterHandler(InvalidationHandler* handler) OVERRIDE;
virtual void UpdateRegisteredIds(InvalidationHandler* handler,
const ObjectIdSet& ids) OVERRIDE;
virtual void UnregisterHandler(InvalidationHandler* handler) OVERRIDE;
virtual InvalidatorState GetInvalidatorState() const OVERRIDE;
virtual void UpdateCredentials(
const std::string& email, const std::string& token) OVERRIDE;
virtual void RequestDetailedStatus(
base::Callback<void(const base::DictionaryValue&)> callback) const
OVERRIDE;
// Static functions to construct callback that creates network channel for
// SyncSystemResources. The goal is to pass network channel to invalidator at
// the same time not exposing channel specific parameters to invalidator and
// channel implementation to client of invalidator.
static NetworkChannelCreator MakePushClientChannelCreator(
const notifier::NotifierOptions& notifier_options);
static NetworkChannelCreator MakeGCMNetworkChannelCreator(
scoped_refptr<net::URLRequestContextGetter> request_context_getter,
scoped_ptr<GCMNetworkChannelDelegate> delegate);
// These methods are forwarded to the invalidation_state_tracker_.
virtual void ClearAndSetNewClientId(const std::string& data) OVERRIDE;
virtual std::string GetInvalidatorClientId() const OVERRIDE;
virtual void SetBootstrapData(const std::string& data) OVERRIDE;
virtual std::string GetBootstrapData() const OVERRIDE;
virtual void SetSavedInvalidations(
const UnackedInvalidationsMap& states) OVERRIDE;
virtual UnackedInvalidationsMap GetSavedInvalidations() const OVERRIDE;
virtual void Clear() OVERRIDE;
private:
void OnInvalidatorStateChange(InvalidatorState state);
void OnIncomingInvalidation(const ObjectIdInvalidationMap& invalidation_map);
std::string GetOwnerName() const;
friend class NonBlockingInvalidatorTestDelegate;
struct InitializeOptions;
class Core;
InvalidatorRegistrar registrar_;
InvalidationStateTracker* invalidation_state_tracker_;
// The real guts of NonBlockingInvalidator, which allows this class to live
// completely on the parent thread.
scoped_refptr<Core> core_;
scoped_refptr<base::SingleThreadTaskRunner> parent_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
base::WeakPtrFactory<NonBlockingInvalidator> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(NonBlockingInvalidator);
};
} // namespace syncer
#endif // SYNC_NOTIFIER_NON_BLOCKING_INVALIDATOR_H_
|
