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
|
// Copyright (c) 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 CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
#define CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
#include <string>
#include "base/basictypes.h"
#include "content/common/content_export.h"
#include "webkit/glue/resource_type.h"
class GURL;
template <class T> class ScopedVector;
namespace appcache {
class AppCacheService;
}
namespace content {
class ResourceContext;
class ResourceThrottle;
struct Referrer;
struct ResourceResponse;
}
namespace IPC {
class Sender;
}
namespace net {
class AuthChallengeInfo;
class SSLCertRequestInfo;
class URLRequest;
}
namespace content {
class ResourceDispatcherHostLoginDelegate;
// Interface that the embedder provides to ResourceDispatcherHost to allow
// observing and modifying requests.
class CONTENT_EXPORT ResourceDispatcherHostDelegate {
public:
// Called when a request begins. Return false to abort the request.
virtual bool ShouldBeginRequest(
int child_id,
int route_id,
const std::string& method,
const GURL& url,
ResourceType::Type resource_type,
ResourceContext* resource_context,
const Referrer& referrer);
// Called after ShouldBeginRequest to allow the embedder to add resource
// throttles.
virtual void RequestBeginning(
net::URLRequest* request,
ResourceContext* resource_context,
appcache::AppCacheService* appcache_service,
ResourceType::Type resource_type,
int child_id,
int route_id,
bool is_continuation_of_transferred_request,
ScopedVector<ResourceThrottle>* throttles);
// Allows an embedder to add additional resource handlers for a download.
// |is_new_request| is true if this is a request that is just starting, i.e.
// the content layer has just added its own resource handlers; it's false if
// this was originally a non-download request that had some resource handlers
// applied already and now we found out it's a download.
// |in_complete| is true if this is invoked from |OnResponseCompleted|.
virtual void DownloadStarting(
net::URLRequest* request,
ResourceContext* resource_context,
int child_id,
int route_id,
int request_id,
bool is_content_initiated,
ScopedVector<ResourceThrottle>* throttles);
// Called when an SSL Client Certificate is requested. If false is returned,
// the request is canceled. Otherwise, the certificate is chosen.
virtual bool AcceptSSLClientCertificateRequest(
net::URLRequest* request,
net::SSLCertRequestInfo* cert_request_info);
// Called when authentication is required and credentials are needed. If
// false is returned, CancelAuth() is called on the URLRequest and the error
// page is shown. If true is returned, the user will be prompted for
// authentication credentials.
virtual bool AcceptAuthRequest(net::URLRequest* request,
net::AuthChallengeInfo* auth_info);
// Creates a ResourceDispatcherHostLoginDelegate that asks the user for a
// username and password.
virtual ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
net::AuthChallengeInfo* auth_info, net::URLRequest* request);
// Launches the url for the given tab. Returns true if an attempt to handle
// the url was made, e.g. by launching an app. Note that this does not
// guarantee that the app successfully handled it.
virtual bool HandleExternalProtocol(const GURL& url,
int child_id,
int route_id);
// Returns true if we should force the given resource to be downloaded.
// Otherwise, the content layer decides.
virtual bool ShouldForceDownloadResource(
const GURL& url, const std::string& mime_type);
// Informs the delegate that a response has started.
virtual void OnResponseStarted(
net::URLRequest* request,
ResourceContext* resource_context,
ResourceResponse* response,
IPC::Sender* sender);
// Informs the delegate that a request has been redirected.
virtual void OnRequestRedirected(
const GURL& redirect_url,
net::URLRequest* request,
ResourceContext* resource_context,
ResourceResponse* response);
protected:
ResourceDispatcherHostDelegate();
virtual ~ResourceDispatcherHostDelegate();
};
} // namespace content
#endif // CONTENT_PUBLIC_BROWSER_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
|
