blob: 4844f440f3f49383060d404b01054d5134cd36b9 (
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
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// Copyright (c) 2011 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 CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
#define CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
#pragma once
#include <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/values.h"
#include "chrome/browser/custom_handlers/protocol_handler.h"
#include "chrome/browser/profiles/profile.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_job.h"
typedef std::map<std::string, ProtocolHandler> ProtocolHandlerMap;
typedef std::vector<ProtocolHandler> ProtocolHandlerList;
typedef std::map<std::string, ProtocolHandlerList> ProtocolHandlerMultiMap;
// This is where handlers for protocols registered with
// navigator.registerProtocolHandler() are registered. Each Profile owns an
// instance of this class, which is initialized on browser start through
// Profile::InitRegisteredProtocolHandlers(), and they should be the only
// instances of this class.
class ProtocolHandlerRegistry
: public base::RefCountedThreadSafe<ProtocolHandlerRegistry> {
public:
class Delegate;
ProtocolHandlerRegistry(Profile* profile, Delegate* delegate);
~ProtocolHandlerRegistry();
// Called when the user accepts the registration of a given protocol handler.
void OnAcceptRegisterProtocolHandler(const ProtocolHandler& handler);
// Called when the user denies the registration of a given protocol handler.
void OnDenyRegisterProtocolHandler(const ProtocolHandler& handler);
// Called when the user indicates that they don't want to be asked about the
// given protocol handler again.
void OnIgnoreRegisterProtocolHandler(const ProtocolHandler& handler);
// Makes this ProtocolHandler the default handler for its protocol.
void SetDefault(const ProtocolHandler& handler);
// Clears the default for the provided protocol.
void ClearDefault(const std::string& scheme);
// Returns true if this handler is the default handler for its protocol.
bool IsDefault(const ProtocolHandler& handler) const;
// Returns true if the given protocol has a default handler associated with
// it.
const bool HasDefault(const std::string& scheme) const;
// Returns true if there is a handler registered for the given protocol.
bool HasHandler(const std::string& scheme);
// Loads a user's registered protocol handlers.
void Load();
// Saves a user's registered protocol handlers.
void Save();
// Returns the default handler for this protocol, or an empty handler if none
// exists.
const ProtocolHandler& GetHandlerFor(const std::string& scheme) const;
// Yields a list of the protocols handled by this registry.
void GetHandledProtocols(std::vector<std::string>* output) const;
// Returns true if we allow websites to register handlers for the given
// scheme.
bool CanSchemeBeOverridden(const std::string& scheme) const;
// Returns true if an identical protocol handler has already been registered.
bool IsRegistered(const ProtocolHandler& handler);
// Returns true if the protocol handler is being ignored.
bool IsIgnored(const ProtocolHandler& handler) const;
// Returns true if the protocol has a registered protocol handler.
bool IsHandledProtocol(const std::string& scheme) const;
// Removes the given protocol handler from the registry.
void RemoveHandler(const ProtocolHandler& handler);
// Causes the given protocol handler to not be ignored anymore.
void RemoveIgnoredHandler(const ProtocolHandler& handler);
// URLRequestFactory for use with URLRequest::RegisterProtocolFactory().
// Redirects any URLRequests for which there is a matching protocol handler.
static net::URLRequestJob* Factory(net::URLRequest* request,
const std::string& scheme);
// Registers the preferences that we store registered protocol handlers in.
static void RegisterPrefs(PrefService* prefService);
// Creates a URL request job for the given request if there is a matching
// protocol handler, returns NULL otherwise.
net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const;
// Puts this registry in the enabled state - registered protocol handlers
// will handle requests.
void Enable();
// Puts this registry in the disabled state - registered protocol handlers
// will not handle requests.
void Disable();
bool enabled() { return enabled_; }
class Delegate {
public:
virtual ~Delegate();
virtual void RegisterExternalHandler(const std::string& protocol);
virtual void DeregisterExternalHandler(const std::string& protocol);
virtual bool IsExternalHandlerRegistered(const std::string& protocol);
};
private:
friend class base::RefCountedThreadSafe<ProtocolHandlerRegistry>;
// Returns a JSON list of protocol handlers. The caller is responsible for
// deleting this Value.
Value* EncodeRegisteredHandlers();
// Returns a JSON list of ignored protocol handlers. The caller is
// responsible for deleting this Value.
Value* EncodeIgnoredHandlers();
// Registers a new protocol handler.
void RegisterProtocolHandler(const ProtocolHandler& handler);
// Get the DictionaryValues stored under the given pref name that are valid
// ProtocolHandler values.
std::vector<const DictionaryValue*> GetHandlersFromPref(
const char* pref_name);
// Ignores future requests to register the given protocol handler.
void IgnoreProtocolHandler(const ProtocolHandler& handler);
// Registers a new protocol handler from a JSON dictionary.
void RegisterHandlerFromValue(const DictionaryValue* value);
// Register
void IgnoreHandlerFromValue(const DictionaryValue* value);
ProtocolHandlerList& GetHandlerListFor(const std::string& scheme);
// Map from protocols (strings) to protocol handlers.
ProtocolHandlerMultiMap protocol_handlers_;
// Protocol handlers that the user has told us to ignore.
ProtocolHandlerList ignored_protocol_handlers_;
// Protocol handlers that are the defaults for a given protocol.
ProtocolHandlerMap default_handlers_;
// The Profile that owns this ProtocolHandlerRegistry.
Profile* profile_;
// The Delegate that registers / deregisters external handlers on our behalf.
scoped_ptr<Delegate> delegate_;
// If false then registered protocol handlers will not be used to handle
// requests.
bool enabled_;
// Whether or not we are loading.
bool is_loading_;
DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerRegistry);
};
#endif // CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
|
