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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// 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.
#ifndef COMPONENTS_WEB_RESOURCE_WEB_RESOURCE_SERVICE_H_
#define COMPONENTS_WEB_RESOURCE_WEB_RESOURCE_SERVICE_H_
#include <stdint.h>
#include <memory>
#include <string>
#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "components/web_resource/resource_request_allowed_notifier.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "url/gurl.h"
class PrefService;
namespace base {
class DictionaryValue;
class Value;
}
namespace net {
class URLFetcher;
class URLRequestContextGetter;
}
namespace web_resource {
// A WebResourceService fetches JSON data from a web server and periodically
// refreshes it.
class WebResourceService
: public net::URLFetcherDelegate,
public ResourceRequestAllowedNotifier::Observer {
public:
// Callbacks for JSON parsing.
using SuccessCallback = base::Callback<void(std::unique_ptr<base::Value>)>;
using ErrorCallback = base::Callback<void(const std::string&)>;
using ParseJSONCallback = base::Callback<
void(const std::string&, const SuccessCallback&, const ErrorCallback&)>;
// Creates a new WebResourceService.
// If |application_locale| is not empty, it will be appended as a locale
// parameter to the resource URL.
WebResourceService(
PrefService* prefs,
const GURL& web_resource_server,
const std::string& application_locale, // May be empty
const char* last_update_time_pref_name,
int start_fetch_delay_ms,
int cache_update_delay_ms,
net::URLRequestContextGetter* request_context,
const char* disable_network_switch,
const ParseJSONCallback& parse_json_callback,
const net::NetworkTrafficAnnotationTag& traffic_annotation);
~WebResourceService() override;
// Sleep until cache needs to be updated, but always for at least
// |start_fetch_delay_ms| so we don't interfere with startup.
// Then begin updating resources.
void StartAfterDelay();
// Sets the ResourceRequestAllowedNotifier to make it configurable.
void SetResourceRequestAllowedNotifier(
std::unique_ptr<ResourceRequestAllowedNotifier> notifier);
protected:
PrefService* prefs_;
bool GetFetchScheduled() const;
private:
friend class WebResourceServiceTest;
// For the subclasses to process the result of a fetch.
virtual void Unpack(const base::DictionaryValue& parsed_json) = 0;
// net::URLFetcherDelegate implementation:
void OnURLFetchComplete(const net::URLFetcher* source) override;
// Schedules a fetch after |delay_ms| milliseconds.
void ScheduleFetch(int64_t delay_ms);
// Starts fetching data from the server.
void StartFetch();
// Set |in_fetch_| to false, clean up temp directories (in the future).
void EndFetch();
// Callbacks from the JSON parser.
void OnUnpackFinished(std::unique_ptr<base::Value> value);
void OnUnpackError(const std::string& error_message);
// Implements ResourceRequestAllowedNotifier::Observer.
void OnResourceRequestsAllowed() override;
// Helper class used to tell this service if it's allowed to make network
// resource requests.
std::unique_ptr<ResourceRequestAllowedNotifier>
resource_request_allowed_notifier_;
// True if we have scheduled a fetch after start_fetch_delay_ms_
// or another one in |cache_update_delay_ms_| time. Set to false
// before fetching starts so that next fetch is scheduled. This
// is to make sure not more than one fetch is scheduled for given
// point in time.
bool fetch_scheduled_;
// The tool that fetches the url data from the server.
std::unique_ptr<net::URLFetcher> url_fetcher_;
// True if we are currently fetching or unpacking data. If we are asked to
// start a fetch when we are still fetching resource data, schedule another
// one in |cache_update_delay_ms_| time, and silently exit.
bool in_fetch_;
// URL that hosts the web resource.
GURL web_resource_server_;
// Application locale, appended to the URL if not empty.
std::string application_locale_;
// Pref name to store the last update's time.
const char* last_update_time_pref_name_;
// Delay on first fetch so we don't interfere with startup.
int start_fetch_delay_ms_;
// Delay between calls to update the web resource cache. This delay may be
// different for different builds of Chrome.
int cache_update_delay_ms_;
// The request context for the resource fetch.
scoped_refptr<net::URLRequestContextGetter> request_context_;
// Callback used to parse JSON.
ParseJSONCallback parse_json_callback_;
// Network traffic annotation for initialization of URLFetcher.
const net::NetworkTrafficAnnotationTag traffic_annotation_;
// So that we can delay our start so as not to affect start-up time; also,
// so that we can schedule future cache updates.
base::WeakPtrFactory<WebResourceService> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(WebResourceService);
};
} // namespace web_resource
#endif // COMPONENTS_WEB_RESOURCE_WEB_RESOURCE_SERVICE_H_
|
