Add DNS resolution methods to CefRequestContext (issue #1841)

This commit is contained in:
Marshall Greenblatt 2016-02-23 18:27:05 -05:00
parent fabd3db33e
commit a1d9c22b58
16 changed files with 593 additions and 8 deletions

View File

@ -252,6 +252,8 @@
'libcef_dll/ctocpp/request_context_handler_ctocpp.h',
'libcef_dll/ctocpp/request_handler_ctocpp.cc',
'libcef_dll/ctocpp/request_handler_ctocpp.h',
'libcef_dll/ctocpp/resolve_callback_ctocpp.cc',
'libcef_dll/ctocpp/resolve_callback_ctocpp.h',
'libcef_dll/cpptoc/resource_bundle_cpptoc.cc',
'libcef_dll/cpptoc/resource_bundle_cpptoc.h',
'libcef_dll/ctocpp/resource_bundle_handler_ctocpp.cc',
@ -452,6 +454,8 @@
'libcef_dll/cpptoc/request_context_handler_cpptoc.h',
'libcef_dll/cpptoc/request_handler_cpptoc.cc',
'libcef_dll/cpptoc/request_handler_cpptoc.h',
'libcef_dll/cpptoc/resolve_callback_cpptoc.cc',
'libcef_dll/cpptoc/resolve_callback_cpptoc.h',
'libcef_dll/ctocpp/resource_bundle_ctocpp.cc',
'libcef_dll/ctocpp/resource_bundle_ctocpp.h',
'libcef_dll/cpptoc/resource_bundle_handler_cpptoc.cc',

View File

@ -49,6 +49,26 @@ extern "C" {
struct _cef_scheme_handler_factory_t;
///
// Callback structure for cef_request_tContext::ResolveHost.
///
typedef struct _cef_resolve_callback_t {
///
// Base structure.
///
cef_base_t base;
///
// Called after the ResolveHost request has completed. |result| will be the
// result code. |resolved_ips| will be the list of resolved IP addresses or
// NULL if the resolution failed.
///
void (CEF_CALLBACK *on_resolve_completed)(
struct _cef_resolve_callback_t* self, cef_errorcode_t result,
cef_string_list_t resolved_ips);
} cef_resolve_callback_t;
///
// A request context provides request handling for a set of related browser or
// URL request objects. A request context can be specified when creating a new
@ -222,6 +242,23 @@ typedef struct _cef_request_context_t {
void (CEF_CALLBACK *close_all_connections)(
struct _cef_request_context_t* self,
struct _cef_completion_callback_t* callback);
///
// Attempts to resolve |origin| to a list of associated IP addresses.
// |callback| will be executed on the UI thread after completion.
///
void (CEF_CALLBACK *resolve_host)(struct _cef_request_context_t* self,
const cef_string_t* origin, struct _cef_resolve_callback_t* callback);
///
// Attempts to resolve |origin| to a list of associated IP addresses using
// cached data. |resolved_ips| will be populated with the list of resolved IP
// addresses or NULL if no cached data is available. Returns ERR_NONE on
// success. This function must be called on the browser process IO thread.
///
cef_errorcode_t (CEF_CALLBACK *resolve_host_cached)(
struct _cef_request_context_t* self, const cef_string_t* origin,
cef_string_list_t resolved_ips);
} cef_request_context_t;

View File

@ -38,6 +38,8 @@
#define CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_
#pragma once
#include <vector>
#include "include/cef_callback.h"
#include "include/cef_cookie.h"
#include "include/cef_request_context_handler.h"
@ -45,6 +47,25 @@
class CefSchemeHandlerFactory;
///
// Callback interface for CefRequestContext::ResolveHost.
///
/*--cef(source=client)--*/
class CefResolveCallback : public virtual CefBase {
public:
///
// Called after the ResolveHost request has completed. |result| will be the
// result code. |resolved_ips| will be the list of resolved IP addresses or
// empty if the resolution failed.
///
/*--cef(optional_param=resolved_ips)--*/
virtual void OnResolveCompleted(
cef_errorcode_t result,
const std::vector<CefString>& resolved_ips) =0;
};
///
// A request context provides request handling for a set of related browser
// or URL request objects. A request context can be specified when creating a
@ -240,6 +261,26 @@ class CefRequestContext : public virtual CefBase {
/*--cef(optional_param=callback)--*/
virtual void CloseAllConnections(
CefRefPtr<CefCompletionCallback> callback) =0;
///
// Attempts to resolve |origin| to a list of associated IP addresses.
// |callback| will be executed on the UI thread after completion.
///
/*--cef()--*/
virtual void ResolveHost(
const CefString& origin,
CefRefPtr<CefResolveCallback> callback) =0;
///
// Attempts to resolve |origin| to a list of associated IP addresses using
// cached data. |resolved_ips| will be populated with the list of resolved IP
// addresses or empty if no cached data is available. Returns ERR_NONE on
// success. This method must be called on the browser process IO thread.
///
/*--cef(default_retval=ERR_FAILED)--*/
virtual cef_errorcode_t ResolveHostCached(
const CefString& origin,
std::vector<CefString>& resolved_ips) =0;
};
#endif // CEF_INCLUDE_CEF_REQUEST_CONTEXT_H_

View File

@ -50,6 +50,30 @@ const char* GetTypeString(base::Value::Type type) {
return "UNKNOWN";
}
// Helper for HostResolver::Resolve.
struct ResolveHostHelper {
explicit ResolveHostHelper(CefRefPtr<CefResolveCallback> callback)
: callback_(callback) {
}
void OnResolveCompleted(int result) {
std::vector<CefString> resolved_ips;
net::AddressList::const_iterator iter = address_list_.begin();
for (; iter != address_list_.end(); ++iter)
resolved_ips.push_back(iter->ToStringWithoutPort());
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefResolveCallback::OnResolveCompleted, callback_.get(),
static_cast<cef_errorcode_t>(result), resolved_ips));
delete this;
}
CefRefPtr<CefResolveCallback> callback_;
net::AddressList address_list_;
};
} // namespace
@ -463,6 +487,47 @@ void CefRequestContextImpl::CloseAllConnections(
callback));
}
void CefRequestContextImpl::ResolveHost(
const CefString& origin,
CefRefPtr<CefResolveCallback> callback) {
GetRequestContextImpl(
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
base::Bind(&CefRequestContextImpl::ResolveHostInternal, this, origin,
callback));
}
cef_errorcode_t CefRequestContextImpl::ResolveHostCached(
const CefString& origin,
std::vector<CefString>& resolved_ips) {
resolved_ips.clear();
if (!CEF_CURRENTLY_ON_IOT()) {
NOTREACHED() << "called on invalid thread";
return ERR_FAILED;
}
if (!request_context_impl_)
return ERR_FAILED;
int retval = ERR_FAILED;
net::HostResolver* host_resolver = request_context_impl_->GetHostResolver();
if (host_resolver) {
net::HostResolver::RequestInfo request_info(
net::HostPortPair::FromURL(GURL(origin.ToString())));
net::AddressList address_list;
retval = host_resolver->ResolveFromCache(request_info, &address_list,
net::BoundNetLog());
if (retval == net::OK) {
net::AddressList::const_iterator iter = address_list.begin();
for (; iter != address_list.end(); ++iter)
resolved_ips.push_back(iter->ToString());
}
}
return static_cast<cef_errorcode_t>(retval);
}
CefRequestContextImpl::CefRequestContextImpl(
scoped_refptr<CefBrowserContext> browser_context)
: browser_context_(browser_context),
@ -605,3 +670,33 @@ void CefRequestContextImpl::CloseAllConnectionsInternal(
base::Bind(&CefCompletionCallback::OnComplete, callback.get()));
}
}
void CefRequestContextImpl::ResolveHostInternal(
const CefString& origin,
CefRefPtr<CefResolveCallback> callback,
scoped_refptr<CefURLRequestContextGetterImpl> request_context) {
CEF_REQUIRE_IOT();
int retval = ERR_FAILED;
// |helper| will be deleted in ResolveHostHelper::OnResolveCompleted().
ResolveHostHelper* helper = new ResolveHostHelper(callback);
net::HostResolver* host_resolver = request_context->GetHostResolver();
if (host_resolver) {
net::HostResolver::RequestInfo request_info(
net::HostPortPair::FromURL(GURL(origin.ToString())));
retval = host_resolver->Resolve(
request_info, net::DEFAULT_PRIORITY,
&helper->address_list_,
base::Bind(&ResolveHostHelper::OnResolveCompleted,
base::Unretained(helper)),
NULL, net::BoundNetLog());
if (retval == net::ERR_IO_PENDING) {
// The result will be delivered asynchronously via the callback.
return;
}
}
helper->OnResolveCompleted(retval);
}

View File

@ -72,6 +72,12 @@ class CefRequestContextImpl : public CefRequestContext {
void ClearCertificateExceptions(
CefRefPtr<CefCompletionCallback> callback) override;
void CloseAllConnections(CefRefPtr<CefCompletionCallback> callback) override;
void ResolveHost(
const CefString& origin,
CefRefPtr<CefResolveCallback> callback) override;
cef_errorcode_t ResolveHostCached(
const CefString& origin,
std::vector<CefString>& resolved_ips) override;
const CefRequestContextSettings& settings() const { return settings_; }
@ -112,6 +118,10 @@ class CefRequestContextImpl : public CefRequestContext {
void CloseAllConnectionsInternal(
CefRefPtr<CefCompletionCallback> callback,
scoped_refptr<CefURLRequestContextGetterImpl> request_context);
void ResolveHostInternal(
const CefString& origin,
CefRefPtr<CefResolveCallback> callback,
scoped_refptr<CefURLRequestContextGetterImpl> request_context);
scoped_refptr<CefBrowserContext> browser_context_;
CefRequestContextSettings settings_;

View File

@ -16,7 +16,9 @@
#include "libcef_dll/cpptoc/value_cpptoc.h"
#include "libcef_dll/ctocpp/completion_callback_ctocpp.h"
#include "libcef_dll/ctocpp/request_context_handler_ctocpp.h"
#include "libcef_dll/ctocpp/resolve_callback_ctocpp.h"
#include "libcef_dll/ctocpp/scheme_handler_factory_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// GLOBAL FUNCTIONS - Body may be edited by hand.
@ -378,6 +380,64 @@ void CEF_CALLBACK request_context_close_all_connections(
CefCompletionCallbackCToCpp::Wrap(callback));
}
void CEF_CALLBACK request_context_resolve_host(
struct _cef_request_context_t* self, const cef_string_t* origin,
cef_resolve_callback_t* callback) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return;
// Verify param: origin; type: string_byref_const
DCHECK(origin);
if (!origin)
return;
// Verify param: callback; type: refptr_diff
DCHECK(callback);
if (!callback)
return;
// Execute
CefRequestContextCppToC::Get(self)->ResolveHost(
CefString(origin),
CefResolveCallbackCToCpp::Wrap(callback));
}
cef_errorcode_t CEF_CALLBACK request_context_resolve_host_cached(
struct _cef_request_context_t* self, const cef_string_t* origin,
cef_string_list_t resolved_ips) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return ERR_FAILED;
// Verify param: origin; type: string_byref_const
DCHECK(origin);
if (!origin)
return ERR_FAILED;
// Verify param: resolved_ips; type: string_vec_byref
DCHECK(resolved_ips);
if (!resolved_ips)
return ERR_FAILED;
// Translate param: resolved_ips; type: string_vec_byref
std::vector<CefString> resolved_ipsList;
transfer_string_list_contents(resolved_ips, resolved_ipsList);
// Execute
cef_errorcode_t _retval = CefRequestContextCppToC::Get(
self)->ResolveHostCached(
CefString(origin),
resolved_ipsList);
// Restore param: resolved_ips; type: string_vec_byref
cef_string_list_clear(resolved_ips);
transfer_string_list_contents(resolved_ipsList, resolved_ips);
// Return type: simple
return _retval;
}
} // namespace
@ -405,6 +465,8 @@ CefRequestContextCppToC::CefRequestContextCppToC() {
GetStruct()->clear_certificate_exceptions =
request_context_clear_certificate_exceptions;
GetStruct()->close_all_connections = request_context_close_all_connections;
GetStruct()->resolve_host = request_context_resolve_host;
GetStruct()->resolve_host_cached = request_context_resolve_host_cached;
}
template<> CefRefPtr<CefRequestContext> CefCppToC<CefRequestContextCppToC,

View File

@ -0,0 +1,64 @@
// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/cpptoc/resolve_callback_cpptoc.h"
#include "libcef_dll/transfer_util.h"
namespace {
// MEMBER FUNCTIONS - Body may be edited by hand.
void CEF_CALLBACK resolve_callback_on_resolve_completed(
struct _cef_resolve_callback_t* self, cef_errorcode_t result,
cef_string_list_t resolved_ips) {
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
DCHECK(self);
if (!self)
return;
// Unverified params: resolved_ips
// Translate param: resolved_ips; type: string_vec_byref_const
std::vector<CefString> resolved_ipsList;
transfer_string_list_contents(resolved_ips, resolved_ipsList);
// Execute
CefResolveCallbackCppToC::Get(self)->OnResolveCompleted(
result,
resolved_ipsList);
}
} // namespace
// CONSTRUCTOR - Do not edit by hand.
CefResolveCallbackCppToC::CefResolveCallbackCppToC() {
GetStruct()->on_resolve_completed = resolve_callback_on_resolve_completed;
}
template<> CefRefPtr<CefResolveCallback> CefCppToC<CefResolveCallbackCppToC,
CefResolveCallback, cef_resolve_callback_t>::UnwrapDerived(
CefWrapperType type, cef_resolve_callback_t* s) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCppToC<CefResolveCallbackCppToC,
CefResolveCallback, cef_resolve_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCppToC<CefResolveCallbackCppToC,
CefResolveCallback, cef_resolve_callback_t>::kWrapperType =
WT_RESOLVE_CALLBACK;

View File

@ -0,0 +1,37 @@
// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#ifndef CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_
#define CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_
#pragma once
#ifndef USING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_CEF_SHARED
#include "include/cef_request_context.h"
#include "include/capi/cef_request_context_capi.h"
#include "include/cef_scheme.h"
#include "include/capi/cef_scheme_capi.h"
#include "libcef_dll/cpptoc/cpptoc.h"
// Wrap a C++ class with a C structure.
// This class may be instantiated and accessed wrapper-side only.
class CefResolveCallbackCppToC
: public CefCppToC<CefResolveCallbackCppToC, CefResolveCallback,
cef_resolve_callback_t> {
public:
CefResolveCallbackCppToC();
};
#endif // USING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CPPTOC_RESOLVE_CALLBACK_CPPTOC_H_

View File

@ -12,11 +12,13 @@
#include "libcef_dll/cpptoc/completion_callback_cpptoc.h"
#include "libcef_dll/cpptoc/request_context_handler_cpptoc.h"
#include "libcef_dll/cpptoc/resolve_callback_cpptoc.h"
#include "libcef_dll/cpptoc/scheme_handler_factory_cpptoc.h"
#include "libcef_dll/ctocpp/cookie_manager_ctocpp.h"
#include "libcef_dll/ctocpp/dictionary_value_ctocpp.h"
#include "libcef_dll/ctocpp/request_context_ctocpp.h"
#include "libcef_dll/ctocpp/value_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// STATIC METHODS - Body may be edited by hand.
@ -355,6 +357,64 @@ void CefRequestContextCToCpp::CloseAllConnections(
CefCompletionCallbackCppToC::Wrap(callback));
}
void CefRequestContextCToCpp::ResolveHost(const CefString& origin,
CefRefPtr<CefResolveCallback> callback) {
cef_request_context_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, resolve_host))
return;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: origin; type: string_byref_const
DCHECK(!origin.empty());
if (origin.empty())
return;
// Verify param: callback; type: refptr_diff
DCHECK(callback.get());
if (!callback.get())
return;
// Execute
_struct->resolve_host(_struct,
origin.GetStruct(),
CefResolveCallbackCppToC::Wrap(callback));
}
cef_errorcode_t CefRequestContextCToCpp::ResolveHostCached(
const CefString& origin, std::vector<CefString>& resolved_ips) {
cef_request_context_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, resolve_host_cached))
return ERR_FAILED;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Verify param: origin; type: string_byref_const
DCHECK(!origin.empty());
if (origin.empty())
return ERR_FAILED;
// Translate param: resolved_ips; type: string_vec_byref
cef_string_list_t resolved_ipsList = cef_string_list_alloc();
DCHECK(resolved_ipsList);
if (resolved_ipsList)
transfer_string_list_contents(resolved_ips, resolved_ipsList);
// Execute
cef_errorcode_t _retval = _struct->resolve_host_cached(_struct,
origin.GetStruct(),
resolved_ipsList);
// Restore param:resolved_ips; type: string_vec_byref
if (resolved_ipsList) {
resolved_ips.clear();
transfer_string_list_contents(resolved_ipsList, resolved_ips);
cef_string_list_free(resolved_ipsList);
}
// Return type: simple
return _retval;
}
// CONSTRUCTOR - Do not edit by hand.

View File

@ -18,6 +18,7 @@
#pragma message("Warning: "__FILE__" may be accessed wrapper-side only")
#else // USING_CEF_SHARED
#include <vector>
#include "include/cef_request_context.h"
#include "include/capi/cef_request_context_capi.h"
#include "include/cef_scheme.h"
@ -55,6 +56,10 @@ class CefRequestContextCToCpp
void ClearCertificateExceptions(
CefRefPtr<CefCompletionCallback> callback) OVERRIDE;
void CloseAllConnections(CefRefPtr<CefCompletionCallback> callback) OVERRIDE;
void ResolveHost(const CefString& origin,
CefRefPtr<CefResolveCallback> callback) OVERRIDE;
cef_errorcode_t ResolveHostCached(const CefString& origin,
std::vector<CefString>& resolved_ips) OVERRIDE;
};
#endif // USING_CEF_SHARED

View File

@ -0,0 +1,65 @@
// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#include "libcef_dll/ctocpp/resolve_callback_ctocpp.h"
#include "libcef_dll/transfer_util.h"
// VIRTUAL METHODS - Body may be edited by hand.
void CefResolveCallbackCToCpp::OnResolveCompleted(cef_errorcode_t result,
const std::vector<CefString>& resolved_ips) {
cef_resolve_callback_t* _struct = GetStruct();
if (CEF_MEMBER_MISSING(_struct, on_resolve_completed))
return;
// AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
// Unverified params: resolved_ips
// Translate param: resolved_ips; type: string_vec_byref_const
cef_string_list_t resolved_ipsList = cef_string_list_alloc();
DCHECK(resolved_ipsList);
if (resolved_ipsList)
transfer_string_list_contents(resolved_ips, resolved_ipsList);
// Execute
_struct->on_resolve_completed(_struct,
result,
resolved_ipsList);
// Restore param:resolved_ips; type: string_vec_byref_const
if (resolved_ipsList)
cef_string_list_free(resolved_ipsList);
}
// CONSTRUCTOR - Do not edit by hand.
CefResolveCallbackCToCpp::CefResolveCallbackCToCpp() {
}
template<> cef_resolve_callback_t* CefCToCpp<CefResolveCallbackCToCpp,
CefResolveCallback, cef_resolve_callback_t>::UnwrapDerived(
CefWrapperType type, CefResolveCallback* c) {
NOTREACHED() << "Unexpected class type: " << type;
return NULL;
}
#ifndef NDEBUG
template<> base::AtomicRefCount CefCToCpp<CefResolveCallbackCToCpp,
CefResolveCallback, cef_resolve_callback_t>::DebugObjCt = 0;
#endif
template<> CefWrapperType CefCToCpp<CefResolveCallbackCToCpp,
CefResolveCallback, cef_resolve_callback_t>::kWrapperType =
WT_RESOLVE_CALLBACK;

View File

@ -0,0 +1,42 @@
// Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.
//
// ---------------------------------------------------------------------------
//
// This file was generated by the CEF translator tool. If making changes by
// hand only do so within the body of existing method and function
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
#ifndef CEF_LIBCEF_DLL_CTOCPP_RESOLVE_CALLBACK_CTOCPP_H_
#define CEF_LIBCEF_DLL_CTOCPP_RESOLVE_CALLBACK_CTOCPP_H_
#pragma once
#ifndef BUILDING_CEF_SHARED
#pragma message("Warning: "__FILE__" may be accessed DLL-side only")
#else // BUILDING_CEF_SHARED
#include <vector>
#include "include/cef_request_context.h"
#include "include/capi/cef_request_context_capi.h"
#include "include/cef_scheme.h"
#include "include/capi/cef_scheme_capi.h"
#include "libcef_dll/ctocpp/ctocpp.h"
// Wrap a C structure with a C++ class.
// This class may be instantiated and accessed DLL-side only.
class CefResolveCallbackCToCpp
: public CefCToCpp<CefResolveCallbackCToCpp, CefResolveCallback,
cef_resolve_callback_t> {
public:
CefResolveCallbackCToCpp();
// CefResolveCallback methods.
void OnResolveCompleted(cef_errorcode_t result,
const std::vector<CefString>& resolved_ips) override;
};
#endif // BUILDING_CEF_SHARED
#endif // CEF_LIBCEF_DLL_CTOCPP_RESOLVE_CALLBACK_CTOCPP_H_

View File

@ -102,6 +102,7 @@
#include "libcef_dll/ctocpp/render_handler_ctocpp.h"
#include "libcef_dll/ctocpp/render_process_handler_ctocpp.h"
#include "libcef_dll/ctocpp/request_handler_ctocpp.h"
#include "libcef_dll/ctocpp/resolve_callback_ctocpp.h"
#include "libcef_dll/ctocpp/resource_bundle_handler_ctocpp.h"
#include "libcef_dll/ctocpp/resource_handler_ctocpp.h"
#include "libcef_dll/ctocpp/response_filter_ctocpp.h"
@ -247,6 +248,7 @@ CEF_EXPORT void cef_shutdown() {
&CefRenderProcessHandlerCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefRequestCallbackCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefRequestHandlerCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefResolveCallbackCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(
&CefResourceBundleHandlerCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefResourceHandlerCToCpp::DebugObjCt));

View File

@ -60,6 +60,7 @@
#include "libcef_dll/cpptoc/render_handler_cpptoc.h"
#include "libcef_dll/cpptoc/render_process_handler_cpptoc.h"
#include "libcef_dll/cpptoc/request_handler_cpptoc.h"
#include "libcef_dll/cpptoc/resolve_callback_cpptoc.h"
#include "libcef_dll/cpptoc/resource_bundle_handler_cpptoc.h"
#include "libcef_dll/cpptoc/resource_handler_cpptoc.h"
#include "libcef_dll/cpptoc/response_filter_cpptoc.h"
@ -239,6 +240,7 @@ CEF_GLOBAL void CefShutdown() {
&CefRenderProcessHandlerCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefRequestCallbackCToCpp::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefRequestHandlerCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefResolveCallbackCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(
&CefResourceBundleHandlerCppToC::DebugObjCt));
DCHECK(base::AtomicRefCountIsZero(&CefResourceHandlerCppToC::DebugObjCt));

View File

@ -76,6 +76,7 @@ enum CefWrapperType {
WT_REQUEST_CONTEXT,
WT_REQUEST_CONTEXT_HANDLER,
WT_REQUEST_HANDLER,
WT_RESOLVE_CALLBACK,
WT_RESOURCE_BUNDLE,
WT_RESOURCE_BUNDLE_HANDLER,
WT_RESOURCE_HANDLER,

View File

@ -654,17 +654,23 @@ TEST(RequestContextTest, NoReferrerLinkDifferentOrigin) {
namespace {
const char kResolveOrigin[] = "http://www.google.com";
class MethodTestHandler : public TestHandler {
public:
enum Method {
METHOD_CLEAR_CERTIFICATE_EXCEPTIONS,
METHOD_CLOSE_ALL_CONNECTIONS,
METHOD_RESOLVE_HOST,
};
class CompletionCallback : public CefCompletionCallback {
class CompletionCallback : public CefCompletionCallback,
public CefResolveCallback {
public:
explicit CompletionCallback(MethodTestHandler* test_handler)
: test_handler_(test_handler) {
CompletionCallback(MethodTestHandler* test_handler,
CefRefPtr<CefBrowser> browser)
: test_handler_(test_handler),
browser_(browser) {
}
~CompletionCallback() override {
@ -679,12 +685,22 @@ class MethodTestHandler : public TestHandler {
// OnComplete should be executed only one time.
EXPECT_TRUE(test_handler_);
test_handler_->OnCompleteCallback();
test_handler_->OnCompleteCallback(browser_);
test_handler_ = nullptr;
browser_ = nullptr;
}
void OnResolveCompleted(
cef_errorcode_t result,
const std::vector<CefString>& resolved_ips) override {
EXPECT_EQ(ERR_NONE, result);
EXPECT_TRUE(!resolved_ips.empty());
OnComplete();
}
private:
MethodTestHandler* test_handler_;
CefRefPtr<CefBrowser> browser_;
IMPLEMENT_REFCOUNTING(CompletionCallback);
};
@ -717,18 +733,42 @@ class MethodTestHandler : public TestHandler {
int httpStatusCode) override {
CefRefPtr<CefRequestContext> context =
browser->GetHost()->GetRequestContext();
CefRefPtr<CefCompletionCallback> callback = new CompletionCallback(this);
CefRefPtr<CompletionCallback> callback =
new CompletionCallback(this, browser);
if (method_ == METHOD_CLEAR_CERTIFICATE_EXCEPTIONS)
context->ClearCertificateExceptions(callback);
else if (method_ == METHOD_CLOSE_ALL_CONNECTIONS)
context->CloseAllConnections(callback);
else if (method_ == METHOD_RESOLVE_HOST)
context->ResolveHost(kResolveOrigin, callback);
}
void OnCompleteCallback() {
void OnCompleteCallback(CefRefPtr<CefBrowser> browser) {
EXPECT_UI_THREAD();
EXPECT_FALSE(got_completion_callback_);
got_completion_callback_.yes();
DestroyTest();
if (method_ == METHOD_RESOLVE_HOST) {
// Now try a cached request.
CefPostTask(TID_IO,
base::Bind(&MethodTestHandler::ResolveHostCached, this, browser));
} else {
DestroyTest();
}
}
void ResolveHostCached(CefRefPtr<CefBrowser> browser) {
EXPECT_IO_THREAD();
CefRefPtr<CefRequestContext> context =
browser->GetHost()->GetRequestContext();
std::vector<CefString> resolved_ips;
cef_errorcode_t result =
context->ResolveHostCached(kResolveOrigin, resolved_ips);
EXPECT_EQ(ERR_NONE, result);
EXPECT_TRUE(!resolved_ips.empty());
CefPostTask(TID_UI, base::Bind(&MethodTestHandler::DestroyTest, this));
}
private:
@ -781,4 +821,22 @@ TEST(RequestContextTest, CloseAllConnectionsCustom) {
MethodTestHandler::METHOD_CLOSE_ALL_CONNECTIONS);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
}
// Test CefRequestContext::ResolveHost with the global context.
TEST(RequestContextTest, ResolveHostGlobal) {
CefRefPtr<MethodTestHandler> handler =
new MethodTestHandler(true,
MethodTestHandler::METHOD_RESOLVE_HOST);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}
// Test CefRequestContext::ResolveHost with a custom context.
TEST(RequestContextTest, ResolveHostCustom) {
CefRefPtr<MethodTestHandler> handler =
new MethodTestHandler(false,
MethodTestHandler::METHOD_RESOLVE_HOST);
handler->ExecuteTest();
ReleaseAndWaitForDestructor(handler);
}