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
|
// Copyright (c) 2010 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 NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
#define NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/scoped_ptr.h"
#include "base/singleton.h"
#include "base/threading/thread_checker_impl.h"
#include "googleurl/src/gurl.h"
#include "net/url_request/url_request_throttler_entry.h"
namespace net {
// 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.
//
// URLRequestThrottlerManager 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.
//
// NOTE: All usage of the singleton object of this class should be on the same
// thread.
//
// TODO(joi): Switch back to NonThreadSafe (and remove checks in release builds)
// once crbug.com/71721 has been tracked down.
class URLRequestThrottlerManager {
public:
static URLRequestThrottlerManager* GetInstance();
// 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 url_request_throttler_entry_interface.h for further
// informations.
scoped_refptr<URLRequestThrottlerEntryInterface> RegisterRequestUrl(
const GURL& url);
// 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, URLRequestThrottlerEntry* entry);
// 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);
void InitializeOptions(bool enforce_throttling);
bool enforce_throttling() const { return enforce_throttling_; }
protected:
URLRequestThrottlerManager();
~URLRequestThrottlerManager();
// 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;
// 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();
// Method that does the actual work of garbage collecting.
void GarbageCollectEntries();
// Used by tests.
int GetNumberOfEntriesForTests() const { return url_entries_.size(); }
private:
friend struct DefaultSingletonTraits<URLRequestThrottlerManager>;
// From each URL we generate an ID composed of the scheme, host, port and path
// that allows us to uniquely map an entry to it.
typedef std::map<std::string, scoped_refptr<URLRequestThrottlerEntry> >
UrlEntryMap;
// 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;
// Constructor copies the string "MAGICZZ\0" into this buffer; using it
// to try to detect memory overwrites affecting url_entries_ in the wild.
// TODO(joi): Remove once crbug.com/71721 is figured out.
char magic_buffer_1_[8];
// Map that contains a list of URL ID and their matching
// URLRequestThrottlerEntry.
UrlEntryMap url_entries_;
// Constructor copies the string "GOOGYZZ\0" into this buffer; using it
// to try to detect memory overwrites affecting url_entries_ in the wild.
// TODO(joi): Remove once crbug.com/71721 is figured out.
char magic_buffer_2_[8];
// 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_;
// Whether we would like to reject outgoing HTTP requests during the back-off
// period.
bool enforce_throttling_;
// Certain tests do not obey the net component's threading policy, so we
// keep track of whether we're being used by tests, and turn off certain
// checks.
//
// TODO(joi): See if we can fix the offending unit tests and remove this
// workaround.
bool being_tested_;
base::ThreadCheckerImpl thread_checker_;
DISALLOW_COPY_AND_ASSIGN(URLRequestThrottlerManager);
};
} // namespace net
#endif // NET_URL_REQUEST_URL_REQUEST_THROTTLER_MANAGER_H_
|
