cefpython/cefpython/cef3/include/cef_request_handler.h at cefpython31 · 2php/cefpython · GitHub

Repository navigation

History

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

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// * Neither the name of Google Inc. nor the name Chromium Embedded

// Framework nor the names of its contributors may be used to endorse

// or promote products derived from this software without specific prior

// written permission.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// ---------------------------------------------------------------------------

// The contents of this file must follow a specific format in order to

// support the CEF translator tool. See the translator.README.txt file in the

// tools directory for more information.

#ifndef CEF_INCLUDE_CEF_REQUEST_HANDLER_H_

#define CEF_INCLUDE_CEF_REQUEST_HANDLER_H_

#pragma once

#include "include/cef_auth_callback.h"

#include "include/cef_base.h"

#include "include/cef_browser.h"

#include "include/cef_frame.h"

#include "include/cef_resource_handler.h"

#include "include/cef_response.h"

#include "include/cef_request.h"

#include "include/cef_web_plugin.h"

///

// Callback interface used for asynchronous continuation of quota requests.

///

/*--cef(source=library)--*/

class CefQuotaCallback : public virtual CefBase {

public:

///

// Continue the quota request. If |allow| is true the request will be

// allowed. Otherwise, the request will be denied.

///

/*--cef(capi_name=cont)--*/

virtual void Continue(bool allow) =0;

///

// Cancel the quota request.

///

/*--cef()--*/

virtual void Cancel() =0;

};

///

// Callback interface used for asynchronous continuation of url requests when

// invalid SSL certificates are encountered.

///

/*--cef(source=library)--*/

class CefAllowCertificateErrorCallback : public virtual CefBase {

public:

///

// Continue the url request. If |allow| is true the request will be

// continued. Otherwise, the request will be canceled.

///

/*--cef(capi_name=cont)--*/

virtual void Continue(bool allow) =0;

};

///

// Implement this interface to handle events related to browser requests. The

// methods of this class will be called on the thread indicated.

///

/*--cef(source=client)--*/

class CefRequestHandler : public virtual CefBase {

public:

typedef cef_termination_status_t TerminationStatus;

///

// Called on the UI thread before browser navigation. Return true to cancel

// the navigation or false to allow the navigation to proceed. The |request|

// object cannot be modified in this callback.

// CefLoadHandler::OnLoadingStateChange will be called twice in all cases.

// If the navigation is allowed CefLoadHandler::OnLoadStart and

// CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled

// CefLoadHandler::OnLoadError will be called with an |errorCode| value of

// ERR_ABORTED.

///

/*--cef()--*/

virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

bool is_redirect) {

return false;

}

///

// Called on the IO thread before a resource request is loaded. The |request|

// object may be modified. To cancel the request return true otherwise return

// false.

///

/*--cef()--*/

virtual bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request) {

return false;

}

///

// Called on the IO thread before a resource is loaded. To allow the resource

// to load normally return NULL. To specify a handler for the resource return

// a CefResourceHandler object. The |request| object should not be modified in

// this callback.

///

/*--cef()--*/

virtual CefRefPtr<CefResourceHandler> GetResourceHandler(

CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request) {

return NULL;

}

///

// Called on the IO thread when a resource load is redirected. The |old_url|

// parameter will contain the old URL. The |new_url| parameter will contain

// the new URL and can be changed if desired.

///

/*--cef()--*/

virtual void OnResourceRedirect(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

const CefString& old_url,

CefString& new_url) {}

///

// Called on the IO thread when the browser needs credentials from the user.

// |isProxy| indicates whether the host is a proxy server. |host| contains the

// hostname and |port| contains the port number. Return true to continue the

// request and call CefAuthCallback::Continue() when the authentication

// information is available. Return false to cancel the request.

///

/*--cef(optional_param=realm)--*/

virtual bool GetAuthCredentials(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

bool isProxy,

const CefString& host,

int port,

const CefString& realm,

const CefString& scheme,

CefRefPtr<CefAuthCallback> callback) {

return false;

}

///

// Called on the IO thread when JavaScript requests a specific storage quota

// size via the webkitStorageInfo.requestQuota function. |origin_url| is the

// origin of the page making the request. |new_size| is the requested quota

// size in bytes. Return true and call CefQuotaCallback::Continue() either in

// this method or at a later time to grant or deny the request. Return false

// to cancel the request.

///

/*--cef(optional_param=realm)--*/

virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,

const CefString& origin_url,

int64 new_size,

CefRefPtr<CefQuotaCallback> callback) {

return false;

}

///

// Called on the UI thread to handle requests for URLs with an unknown

// protocol component. Set |allow_os_execution| to true to attempt execution

// via the registered OS protocol handler, if any.

// SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED

// ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.

///

/*--cef()--*/

virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,

const CefString& url,

bool& allow_os_execution) {}

///

// Called on the UI thread to handle requests for URLs with an invalid

// SSL certificate. Return true and call CefAllowCertificateErrorCallback::

// Continue() either in this method or at a later time to continue or cancel

// the request. Return false to cancel the request immediately. If |callback|

// is empty the error cannot be recovered from and the request will be

// canceled automatically. If CefSettings.ignore_certificate_errors is set

// all invalid certificates will be accepted without calling this method.

///

/*--cef()--*/

virtual bool OnCertificateError(

cef_errorcode_t cert_error,

const CefString& request_url,

CefRefPtr<CefAllowCertificateErrorCallback> callback) {

return false;

}

///

// Called on the browser process IO thread before a plugin is loaded. Return

// true to block loading of the plugin.

///

/*--cef(optional_param=url,optional_param=policy_url)--*/

virtual bool OnBeforePluginLoad(CefRefPtr<CefBrowser> browser,

const CefString& url,

const CefString& policy_url,

CefRefPtr<CefWebPluginInfo> info) {

return false;

}

///

// Called on the browser process UI thread when a plugin has crashed.

// |plugin_path| is the path of the plugin that crashed.

///

/*--cef()--*/

virtual void OnPluginCrashed(CefRefPtr<CefBrowser> browser,

const CefString& plugin_path) {}

///

// Called on the browser process UI thread when the render process

// terminates unexpectedly. |status| indicates how the process

// terminated.

///

/*--cef()--*/

virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,

TerminationStatus status) {}

};

#endif // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_

cefpython/cefpython/cef3/include/cef_request_handler.h at cefpython31 · 2php/cefpython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

cef_request_handler.h

Latest commit

History

Breadcrumbs

cef_request_handler.h

File metadata and controls