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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef EXTENSIONS_RENDERER_EXTENSION_THROTTLE_MANAGER_H_
#define EXTENSIONS_RENDERER_EXTENSION_THROTTLE_MANAGER_H_
#include <map>
#include <memory>
#include <string>
#include "base/synchronization/lock.h"
#include "extensions/renderer/extension_throttle_entry.h"
#include "services/network/public/mojom/url_response_head.mojom-forward.h"
#include "url/gurl.h"
namespace blink {
class URLLoaderThrottle;
class WebURLRequest;
} // namespace blink
namespace net {
struct RedirectInfo;
} // namespace net
namespace extensions {
// This is a thread safe class that registers URL request throttler entries for
// URLs being accessed in order to supervise traffic. URL requests for HTTP
// contents should register their URLs in this manager on each request.
//
// ExtensionThrottleManager maintains a map of URL IDs to URL request
// throttler entries. It creates URL request throttler entries when new URLs
// are registered, and does garbage collection from time to time in order to
// clean out outdated entries. URL ID consists of lowercased scheme, host, port
// and path. All URLs converted to the same ID will share the same entry.
class ExtensionThrottleManager {
public:
ExtensionThrottleManager();
ExtensionThrottleManager(const ExtensionThrottleManager&) = delete;
ExtensionThrottleManager& operator=(const ExtensionThrottleManager&) = delete;
virtual ~ExtensionThrottleManager();
// Creates a throttle which uses this class to prevent extensions from
// requesting a URL too often, if such a throttle is needed.
std::unique_ptr<blink::URLLoaderThrottle> MaybeCreateURLLoaderThrottle(
const blink::WebURLRequest& request);
// Determine if a request to |request_url| should be rejected.
bool ShouldRejectRequest(const GURL& request_url);
// Determine if a redirect from the original |request_url| should be allowed
// to be redirected as specified by |redirect_info|.
bool ShouldRejectRedirect(const GURL& request_url,
const net::RedirectInfo& redirect_info);
// Must be called when the |response_head| for a request has been received.
void WillProcessResponse(
const GURL& response_url,
const network::mojom::URLResponseHead& response_head);
// Set the network status online state as specified in |is_online|.
void SetOnline(bool is_online);
void SetBackoffPolicyForTests(
std::unique_ptr<net::BackoffEntry::Policy> policy);
// Registers a new entry in this service and overrides the existing entry (if
// any) for the URL. The service will hold a reference to the entry.
// It is only used by unit tests.
void OverrideEntryForTests(const GURL& url,
std::unique_ptr<ExtensionThrottleEntry> entry);
int GetNumberOfEntriesForTests() const { return url_entries_.size(); }
protected:
// Method that allows us to transform a URL into an ID that can be used in our
// map. Resulting IDs will be lowercase and consist of the scheme, host, port
// and path (without query string, fragment, etc.).
// If the URL is invalid, the invalid spec will be returned, without any
// transformation.
std::string GetIdFromUrl(const GURL& url) const;
// Must be called for every request, returns the URL request throttler entry
// associated with the URL. The caller must inform this entry of some events.
// Please refer to extension_throttle_entry.h for further information.
ExtensionThrottleEntry* RegisterRequestUrl(const GURL& url);
// Method that does the actual work of garbage collecting.
void GarbageCollectEntries();
private:
// Explicitly erases an entry.
// This is useful to remove those entries which have got infinite lifetime and
// thus won't be garbage collected.
// It is only used by unit tests.
void EraseEntryForTests(const GURL& url);
// Whether throttling is enabled or not.
void set_enforce_throttling(bool enforce);
bool enforce_throttling();
// Method that ensures the map gets cleaned from time to time. The period at
// which garbage collecting happens is adjustable with the
// kRequestBetweenCollecting constant.
void GarbageCollectEntriesIfNecessary();
// Maximum number of entries that we are willing to collect in our map.
static const unsigned int kMaximumNumberOfEntries;
// Number of requests that will be made between garbage collection.
static const unsigned int kRequestsBetweenCollecting;
// Map that contains a list of URL ID (composed of the scheme, host, port and
// path) and their matching ExtensionThrottleEntry.
std::map<std::string, std::unique_ptr<ExtensionThrottleEntry>> url_entries_;
// This keeps track of how many requests have been made. Used with
// GarbageCollectEntries.
unsigned int requests_since_last_gc_;
// Valid after construction.
GURL::Replacements url_id_replacements_;
// This is null when it is not set for tests.
std::unique_ptr<net::BackoffEntry::Policy> backoff_policy_for_tests_;
// Used to synchronize all public methods.
base::Lock lock_;
};
} // namespace extensions
#endif // EXTENSIONS_RENDERER_EXTENSION_THROTTLE_MANAGER_H_
|
