cefpython/src/include/cef_request_handler.h at cefpython58 · 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

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

// 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 <vector>

#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_response_filter.h"

#include "include/cef_request.h"

#include "include/cef_ssl_info.h"

#include "include/cef_x509_certificate.h"

///

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

///

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

class CefRequestCallback : public virtual CefBaseRefCounted {

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;

///

// Cancel the url request.

///

/*--cef()--*/

virtual void Cancel() =0;

};

///

// Callback interface used to select a client certificate for authentication.

///

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

class CefSelectClientCertificateCallback : public virtual CefBaseRefCounted {

public:

///

// Chooses the specified certificate for client certificate authentication.

// NULL value means that no client certificate should be used.

///

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

virtual void Select(CefRefPtr<CefX509Certificate> cert) =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 CefBaseRefCounted {

public:

typedef cef_return_value_t ReturnValue;

typedef cef_termination_status_t TerminationStatus;

typedef cef_urlrequest_status_t URLRequestStatus;

typedef cef_window_open_disposition_t WindowOpenDisposition;

typedef std::vector<CefRefPtr<CefX509Certificate> > X509CertificateList;

///

// 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 UI thread before OnBeforeBrowse in certain limited cases

// where navigating a new or different browser might be desirable. This

// includes user-initiated navigation that might open in a special way (e.g.

// links clicked via middle-click or ctrl + left-click) and certain types of

// cross-origin navigation initiated from the renderer process (e.g.

// navigating the top-level frame to/from a file URL). The |browser| and

// |frame| values represent the source of the navigation. The

// |target_disposition| value indicates where the user intended to navigate

// the browser based on standard Chromium behaviors (e.g. current tab,

// new tab, etc). The |user_gesture| value will be true if the browser

// navigated via explicit user gesture (e.g. clicking a link) or false if it

// navigated automatically (e.g. via the DomContentLoaded event). Return true

// to cancel the navigation or false to allow the navigation to proceed in the

// source browser's top-level frame.

///

/*--cef()--*/

virtual bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

const CefString& target_url,

WindowOpenDisposition target_disposition,

bool user_gesture) {

return false;

}

///

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

// object may be modified. Return RV_CONTINUE to continue the request

// immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback::

// Continue() at a later time to continue or cancel the request

// asynchronously. Return RV_CANCEL to cancel the request immediately.

///

/*--cef(default_retval=RV_CONTINUE)--*/

virtual ReturnValue OnBeforeResourceLoad(

CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

CefRefPtr<CefRequestCallback> callback) {

return RV_CONTINUE;

}

///

// 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 |request|

// parameter will contain the old URL and other request-related information.

// The |response| parameter will contain the response that resulted in the

// redirect. The |new_url| parameter will contain the new URL and can be

// changed if desired. The |request| object cannot be modified in this

// callback.

///

/*--cef()--*/

virtual void OnResourceRedirect(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

CefRefPtr<CefResponse> response,

CefString& new_url) {}

///

// Called on the IO thread when a resource response is received. To allow the

// resource to load normally return false. To redirect or retry the resource

// modify |request| (url, headers or post body) and return true. The

// |response| object cannot be modified in this callback.

///

/*--cef()--*/

virtual bool OnResourceResponse(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

CefRefPtr<CefResponse> response) {

return false;

}

///

// Called on the IO thread to optionally filter resource response content.

// |request| and |response| represent the request and response respectively

// and cannot be modified in this callback.

///

/*--cef()--*/

virtual CefRefPtr<CefResponseFilter> GetResourceResponseFilter(

CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

CefRefPtr<CefResponse> response) {

return NULL;

}

///

// Called on the IO thread when a resource load has completed. |request| and

// |response| represent the request and response respectively and cannot be

// modified in this callback. |status| indicates the load completion status.

// |received_content_length| is the number of response bytes actually read.

///

/*--cef()--*/

virtual void OnResourceLoadComplete(CefRefPtr<CefBrowser> browser,

CefRefPtr<CefFrame> frame,

CefRefPtr<CefRequest> request,

CefRefPtr<CefResponse> response,

URLRequestStatus status,

int64 received_content_length) {}

///

// 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. |realm| is the realm of the

// challenge and may be empty. |scheme| is the authentication scheme used,

// such as "basic" or "digest", and will be empty if the source of the request

// is an FTP server. Return true to continue the request and call

// CefAuthCallback::Continue() either in this method or at a later time when

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

// request immediately.

///

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

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 to continue the request and call

// CefRequestCallback::Continue() either in this method or at a later time to

// grant or deny the request. Return false to cancel the request immediately.

///

/*--cef()--*/

virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,

const CefString& origin_url,

int64 new_size,

CefRefPtr<CefRequestCallback> 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 CefRequestCallback::Continue() either

// in this method or at a later time to continue or cancel the request. Return

// false to cancel the request immediately. If

// CefSettings.ignore_certificate_errors is set all invalid certificates will

// be accepted without calling this method.

///

/*--cef()--*/

virtual bool OnCertificateError(

CefRefPtr<CefBrowser> browser,

cef_errorcode_t cert_error,

const CefString& request_url,

CefRefPtr<CefSSLInfo> ssl_info,

CefRefPtr<CefRequestCallback> callback) {

return false;

}

///

// Called on the UI thread when a client certificate is being requested for

// authentication. Return false to use the default behavior and automatically

// select the first certificate available. Return true and call

// CefSelectClientCertificateCallback::Select either in this method or at a

// later time to select a certificate. Do not call Select or call it with NULL

// to continue without using any certificate. |isProxy| indicates whether the

// host is an HTTPS proxy or the origin server. |host| and |port| contains the

// hostname and port of the SSL server. |certificates| is the list of

// certificates to choose from; this list has already been pruned by Chromium

// so that it only contains certificates from issuers that the server trusts.

///

/*--cef()--*/

virtual bool OnSelectClientCertificate(

CefRefPtr<CefBrowser> browser,

bool isProxy,

const CefString& host,

int port,

const X509CertificateList& certificates,

CefRefPtr<CefSelectClientCertificateCallback> callback) {

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 view associated

// with |browser| is ready to receive/handle IPC messages in the render

// process.

///

/*--cef()--*/

virtual void OnRenderViewReady(CefRefPtr<CefBrowser> browser) {}

///

// 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/src/include/cef_request_handler.h at cefpython58 · 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