#include "Cef3WebVWndHandler.h"
|
#include "include/wrapper/cef_helpers.h"
|
#include "include/cef_parser.h"
|
#include <shlobj.h>
|
#include "Cef3WinUtil.h"
|
#include "Cef3MainContext.h"
|
#include "Cef3ResourceUtil.h"
|
//#include "temp_window_win.h"
|
|
namespace browser {
|
|
#if defined(OS_WIN)
|
#define NEWLINE "\r\n"
|
#else
|
#define NEWLINE "\n"
|
#endif
|
|
|
|
// Custom menu command Ids.
|
enum browser_menu_ids {
|
BROWSER_ID_SHOW_DEVTOOLS = MENU_ID_USER_FIRST,
|
BROWSER_ID_CLOSE_DEVTOOLS,
|
BROWSER_ID_INSPECT_ELEMENT,
|
};
|
|
|
std::string GetWndErrorString(cef_errorcode_t code) {
|
// Case condition that returns |code| as a string.
|
#define CASE(code) case code: return #code
|
|
switch (code) {
|
CASE(ERR_NONE);
|
CASE(ERR_FAILED);
|
CASE(ERR_ABORTED);
|
CASE(ERR_INVALID_ARGUMENT);
|
CASE(ERR_INVALID_HANDLE);
|
CASE(ERR_FILE_NOT_FOUND);
|
CASE(ERR_TIMED_OUT);
|
CASE(ERR_FILE_TOO_BIG);
|
CASE(ERR_UNEXPECTED);
|
CASE(ERR_ACCESS_DENIED);
|
CASE(ERR_NOT_IMPLEMENTED);
|
CASE(ERR_CONNECTION_CLOSED);
|
CASE(ERR_CONNECTION_RESET);
|
CASE(ERR_CONNECTION_REFUSED);
|
CASE(ERR_CONNECTION_ABORTED);
|
CASE(ERR_CONNECTION_FAILED);
|
CASE(ERR_NAME_NOT_RESOLVED);
|
CASE(ERR_INTERNET_DISCONNECTED);
|
CASE(ERR_SSL_PROTOCOL_ERROR);
|
CASE(ERR_ADDRESS_INVALID);
|
CASE(ERR_ADDRESS_UNREACHABLE);
|
CASE(ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
|
CASE(ERR_TUNNEL_CONNECTION_FAILED);
|
CASE(ERR_NO_SSL_VERSIONS_ENABLED);
|
CASE(ERR_SSL_VERSION_OR_CIPHER_MISMATCH);
|
CASE(ERR_SSL_RENEGOTIATION_REQUESTED);
|
CASE(ERR_CERT_COMMON_NAME_INVALID);
|
CASE(ERR_CERT_DATE_INVALID);
|
CASE(ERR_CERT_AUTHORITY_INVALID);
|
CASE(ERR_CERT_CONTAINS_ERRORS);
|
CASE(ERR_CERT_NO_REVOCATION_MECHANISM);
|
CASE(ERR_CERT_UNABLE_TO_CHECK_REVOCATION);
|
CASE(ERR_CERT_REVOKED);
|
CASE(ERR_CERT_INVALID);
|
CASE(ERR_CERT_END);
|
CASE(ERR_INVALID_URL);
|
CASE(ERR_DISALLOWED_URL_SCHEME);
|
CASE(ERR_UNKNOWN_URL_SCHEME);
|
CASE(ERR_TOO_MANY_REDIRECTS);
|
CASE(ERR_UNSAFE_REDIRECT);
|
CASE(ERR_UNSAFE_PORT);
|
CASE(ERR_INVALID_RESPONSE);
|
CASE(ERR_INVALID_CHUNKED_ENCODING);
|
CASE(ERR_METHOD_NOT_SUPPORTED);
|
CASE(ERR_UNEXPECTED_PROXY_AUTH);
|
CASE(ERR_EMPTY_RESPONSE);
|
CASE(ERR_RESPONSE_HEADERS_TOO_BIG);
|
CASE(ERR_CACHE_MISS);
|
CASE(ERR_INSECURE_RESPONSE);
|
default:
|
return "UNKNOWN";
|
}
|
}
|
|
std::string GetWndDataURI(const std::string& data,
|
const std::string& mime_type) {
|
return "data:" + mime_type + ";base64," +
|
CefURIEncode(CefBase64Encode(data.data(), data.size()), false).ToString();
|
}
|
|
// Load a data: URI containing the error message.
|
void LoadWndErrorPage(CefRefPtr<CefFrame> frame,
|
const std::string& failed_url,
|
cef_errorcode_t error_code,
|
const std::string& other_info) {
|
std::stringstream ss;
|
ss << "<html><head><title>Page failed to load</title></head>"
|
"<body bgcolor=\"white\">"
|
"<h3>Page failed to load.</h3>"
|
"URL: <a href=\"" << failed_url << "\">" << failed_url << "</a>"
|
"<br/>Error: " << GetWndErrorString(error_code) <<
|
" (" << error_code << ")";
|
|
if (!other_info.empty())
|
ss << "<br/>" << other_info;
|
|
ss << "</body></html>";
|
frame->LoadURL(GetWndDataURI(ss.str(), "text/html"));
|
}
|
|
|
CCef3WebVWndHandler::CCef3WebVWndHandler() : m_bPageLoaded(FALSE)
|
, first_console_message_(true)
|
, console_log_file_(CCef3MainContext::Get()->GetConsoleLogPath()) {
|
resource_manager_ = new CefResourceManager();
|
m_PopupUrl = _T("");
|
m_strHtml = _T("");
|
}
|
|
CCef3WebVWndHandler::~CCef3WebVWndHandler() {
|
}
|
|
void CCef3WebVWndHandler::CloseDevTools(CefRefPtr<CefBrowser> browser) {
|
browser->GetHost()->CloseDevTools();
|
}
|
|
bool CCef3WebVWndHandler::CreatePopupWindow(
|
CefRefPtr<CefBrowser> browser,
|
bool is_devtools,
|
const CefPopupFeatures& popupFeatures,
|
CefWindowInfo& windowInfo,
|
CefRefPtr<CefClient>& client,
|
CefBrowserSettings& settings) {
|
// Note: This method will be called on multiple threads.
|
|
// The popup browser will be parented to a new native window.
|
// Don't show URL bar and navigation buttons on DevTools windows.
|
//MainContext::Get()->CreateBrowserPopup(is_osr(), popupFeatures, windowInfo, client, settings);
|
|
return false;
|
}
|
|
|
// ------------------------------------------------------------------------------
|
//
|
// cef handler callbacks
|
//
|
// ------------------------------------------------------------------------------
|
|
bool CCef3WebVWndHandler::GetRootScreenRect(CefRefPtr<CefBrowser> browser,
|
CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
RECT window_rect = {0};
|
HWND root_window = GetAncestor(m_hOwnerWnd, GA_ROOT);
|
if (::GetWindowRect(root_window, &window_rect)) {
|
/*CString strMess;
|
strMess.Format(_T("%d,%d,%d,%d"),window_rect.left,
|
window_rect.top,
|
window_rect.right - window_rect.left,
|
window_rect.bottom - window_rect.top);*/
|
//MessageBox(m_hOwnerWnd, strMess, _T("CefÌáʾ GetRootScreenRect"),MB_OK);
|
rect = CefRect(window_rect.left,
|
window_rect.top,
|
window_rect.right - window_rect.left,
|
window_rect.bottom - window_rect.top);
|
return true;
|
}
|
return false;
|
}
|
|
bool CCef3WebVWndHandler::GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
|
RECT clientRect;
|
if (!::GetClientRect(m_hOwnerWnd, &clientRect))
|
return false;
|
rect.x = rect.y = 0;
|
rect.width = clientRect.right;
|
rect.height = clientRect.bottom;
|
//CString strMess;
|
/*strMess.Format(_T("%d,%d,%d,%d"),rect.x,
|
rect.y,
|
rect.width,
|
rect.height);*/
|
//MessageBox(m_hOwnerWnd, strMess, _T("CefÌáʾ GetViewRect"),MB_OK);
|
return true;
|
}
|
|
bool CCef3WebVWndHandler::GetScreenPoint(CefRefPtr<CefBrowser> browser,
|
int viewX,
|
int viewY,
|
int& screenX,
|
int& screenY) {
|
CEF_REQUIRE_UI_THREAD();
|
if (!::IsWindow(m_hOwnerWnd))
|
return false;
|
|
// Convert the point from view coordinates to actual screen coordinates.
|
POINT screen_pt = {viewX, viewY};
|
ClientToScreen(m_hOwnerWnd, &screen_pt);
|
screenX = screen_pt.x;
|
screenY = screen_pt.y;
|
|
return true;
|
}
|
|
bool CCef3WebVWndHandler::GetScreenInfo(CefRefPtr<CefBrowser> browser,
|
CefScreenInfo& screen_info) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
return false;
|
}
|
|
void CCef3WebVWndHandler::OnPopupShow(CefRefPtr<CefBrowser> browser,
|
bool show) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
}
|
|
void CCef3WebVWndHandler::OnPopupSize(CefRefPtr<CefBrowser> browser,
|
const CefRect& rect) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
}
|
|
void CCef3WebVWndHandler::OnPaint(CefRefPtr<CefBrowser> browser,
|
PaintElementType type,
|
const RectList & dirtyRects,
|
const void* buffer, int width, int height) {
|
CEF_REQUIRE_UI_THREAD();
|
|
}
|
|
void CCef3WebVWndHandler::OnCursorChange(CefRefPtr<CefBrowser> browser,
|
CefCursorHandle cursor,
|
CursorType type,
|
const CefCursorInfo& custom_cursor_info) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
}
|
|
bool CCef3WebVWndHandler::StartDragging(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefDragData> drag_data,
|
CefRenderHandler::DragOperationsMask allowed_ops,
|
int x, int y) {
|
CEF_REQUIRE_UI_THREAD();
|
return false;
|
}
|
|
void CCef3WebVWndHandler::UpdateDragCursor(
|
CefRefPtr<CefBrowser> browser,
|
CefRenderHandler::DragOperation operation) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
}
|
|
void CCef3WebVWndHandler::OnImeCompositionRangeChanged(
|
CefRefPtr<CefBrowser> browser,
|
const CefRange& selection_range,
|
const CefRenderHandler::RectList& character_bounds) {
|
CEF_REQUIRE_UI_THREAD();
|
|
}
|
|
bool CCef3WebVWndHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
|
const CefKeyEvent& event,
|
CefEventHandle os_event,
|
bool* is_keyboard_shortcut) {
|
if (!m_bPageLoaded) {
|
return true;
|
}
|
|
CefWindowHandle hWnd = browser->GetHost()->GetWindowHandle();
|
|
//
|
// Í˳ö
|
if (event.character == VK_ESCAPE) {
|
::PostMessage(::GetParent(hWnd), WM_KEYDOWN, event.character, 0);
|
return true;
|
}
|
|
//
|
// µ÷ÊÔ¿ì½Ý¼ü
|
if (IsKeyDown(VK_SHIFT)) {
|
STRACE(L"char:%d", event.character);
|
if (event.character == VK_F12) {
|
OpenDevTools();
|
} else if (event.character == VK_F11) {
|
browser->GetMainFrame()->ViewSource();
|
}
|
}
|
|
return false;
|
}
|
|
bool CCef3WebVWndHandler::DoClose(CefRefPtr<CefBrowser> browser) {
|
CloseDevTools(browser);
|
return false;
|
}
|
|
void CCef3WebVWndHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
|
CEF_REQUIRE_UI_THREAD();
|
browser::CCef3MainContext::Get()->AddOpenedBrowserCount();
|
if(!GetBrowser())
|
{
|
m_refBrowser = browser;
|
base::AutoLock lock_scope(lock_);
|
browser->GetIdentifier();
|
if( !m_strHtml.empty())
|
LoadHtml(m_strHtml);
|
}else if (browser->IsPopup()) {
|
|
|
// Give focus to the popup browser. Perform asynchronously because the
|
// parent window may attempt to keep focus after launching the popup.
|
CefPostTask(TID_UI,
|
base::Bind(&CefBrowserHost::SetFocus, browser->GetHost().get(), true));
|
}
|
}
|
|
void CCef3WebVWndHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
|
|
if (m_refBrowser.get() &&
|
m_refBrowser->GetIdentifier() == browser->GetIdentifier()) {
|
// !!! IMPORTANT !!!
|
m_refBrowser = NULL;
|
STRACE(L"main browser closed");
|
}
|
|
int n = browser::CCef3MainContext::Get()->DelOpenedBrowserCount();
|
//STRACE(L"browser left:%d", n);
|
if (n == 0) {
|
STRACE(L"quit message loop");
|
//CefQuitMessageLoop();
|
}
|
}
|
|
void CCef3WebVWndHandler::OnBeforeDownload(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefDownloadItem> download_item,
|
const CefString& suggested_name,
|
CefRefPtr<CefBeforeDownloadCallback> callback)
|
{
|
::SetFocus(m_hOwnerWnd);
|
|
std::wstring wstrExt = suggested_name.ToWString();
|
|
TCHAR filename[MAX_PATH] = {0};
|
_tcscpy(filename,wstrExt.c_str());
|
|
OPENFILENAME ofn;
|
ZeroMemory(&ofn, sizeof(ofn));
|
ofn.lpstrFile = filename;
|
ofn.nMaxFile = MAX_PATH;
|
ofn.lpstrFilter = _T("All Files(*.*)|*.*||");
|
ofn.lpstrDefExt = _T("");
|
ofn.lpstrTitle = _T("±£´æ");
|
ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
|
ofn.FlagsEx = OFN_EX_NOPLACESBAR;
|
ofn.lStructSize = sizeof(OPENFILENAME); // No OFN_ENABLEHOOK
|
ofn.hwndOwner = m_hOwnerWnd;
|
if (GetSaveFileName(&ofn))
|
{
|
//´Ë´¦Ôõô×ö£¿
|
callback->Continue(ofn.lpstrFile, false);
|
}
|
|
CefRefPtr<CefBrowserHost> host = browser->GetHost();
|
host->SetFocus(true);
|
}
|
|
|
void CCef3WebVWndHandler::OnDownloadUpdated(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefDownloadItem> download_item,
|
CefRefPtr<CefDownloadItemCallback> callback)
|
{
|
if (download_item->IsComplete())
|
{
|
if (download_item->IsComplete())//ÏÂÔØÍê³É
|
{
|
std::wstring sFilePath = download_item->GetFullPath().ToWString();//Äõ½ÏÂÔØÍê³ÉÎļþȫ·¾¶
|
}
|
}
|
}
|
|
CefRefPtr<CefDownloadHandler> CCef3WebVWndHandler::GetDownloadHandler() //ʵÏÖ
|
{
|
return this;
|
}
|
|
// ------------------------------------------------------------------------------
|
//
|
// browser methods for user & internal methods
|
//
|
// ------------------------------------------------------------------------------
|
|
void CCef3WebVWndHandler::OpenDevTools() {
|
if (!m_refBrowser) {
|
return;
|
}
|
|
CefWindowInfo windowInfo;
|
CefBrowserSettings settings;
|
|
windowInfo.SetAsPopup(m_refBrowser->GetHost()->GetWindowHandle(), "DevTools");
|
m_refBrowser->GetHost()->ShowDevTools(windowInfo, this, settings, CefPoint());
|
}
|
|
bool CCef3WebVWndHandler::OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
const CefString& target_url,
|
const CefString& target_frame_name,
|
CefLifeSpanHandler::WindowOpenDisposition target_disposition,
|
bool user_gesture,
|
const CefPopupFeatures& popupFeatures,
|
CefWindowInfo& windowInfo,
|
CefRefPtr<CefClient>& client,
|
CefBrowserSettings& settings,
|
bool* no_javascript_access) {
|
|
m_PopupUrl = target_url.ToWString();
|
::SendMessage(m_hOwnerWnd,WM_WEBURLDIALOG,NULL,NULL);
|
|
return true;//²»ÔÊÐíµ¯´°¿Ú£¬ÓÉÓ¦ÓÃ×Ô¼º¾ö¶¨µ¯²»µ¯
|
}
|
|
std::wstring CCef3WebVWndHandler::GetPopupUrl()
|
{
|
return m_PopupUrl;
|
}
|
|
|
BOOL CCef3WebVWndHandler::Open(HWND hParent,const CefString& url, SOUI::CRect rcView) {
|
CefWindowInfo info;
|
//info.SetAsWindowless(hParent, true);
|
info.SetAsChild(hParent,rcView);
|
m_hOwnerWnd = hParent;
|
|
return !!CefBrowserHost::CreateBrowser(info, this, url, CefBrowserSettings(), nullptr);
|
}
|
|
void CCef3WebVWndHandler::Close() {
|
if (m_refBrowser)
|
m_refBrowser->GetHost()->CloseBrowser(true);
|
}
|
|
void CCef3WebVWndHandler::CloseAllBrowsers(bool force_close) {
|
if (!CefCurrentlyOn(TID_UI)) {
|
// Execute on the UI thread.
|
CefPostTask(TID_UI, base::Bind(&CCef3WebVWndHandler::CloseAllBrowsers, this, force_close));
|
|
return;
|
}
|
|
if (m_refBrowser.get()) {
|
// Request that the main browser close.
|
m_refBrowser->GetHost()->CloseBrowser(force_close);
|
}
|
}
|
|
|
|
CefRefPtr<CefBrowser> CCef3WebVWndHandler::GetBrowser() {
|
base::AutoLock lock_scope(lock_);
|
|
return m_refBrowser;
|
}
|
|
|
void CCef3WebVWndHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
|
const CefString& title) {
|
|
|
}
|
|
|
bool CCef3WebVWndHandler::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
|
const CefString& message,
|
const CefString& source,
|
int line) {
|
CEF_REQUIRE_UI_THREAD();
|
|
//FILE* file = fopen(console_log_file_.c_str(), "a");
|
//if (file) {
|
// /*std::stringstream ss;
|
// ss << "Message: " << message.ToString() << NEWLINE <<
|
// "Source: " << source.ToString() << NEWLINE <<
|
// "Line: " << line << NEWLINE <<
|
// "-----------------------" << NEWLINE;
|
// fputs(ss.str().c_str(), file);
|
// fclose(file);*/
|
|
// if (first_console_message_) {
|
// //test_runner::Alert( browser, "Console messages written to \"" + console_log_file_ + "\"");
|
// first_console_message_ = false;
|
// }
|
//}
|
|
return false;
|
}
|
|
void CCef3WebVWndHandler::OnAddressChange(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
const CefString& url) {
|
CefRefPtr<CefProcessMessage> msg_back = CefProcessMessage::Create(_T("func_backurl"));
|
msg_back->GetArgumentList()->SetString(0, url);
|
msg_back->GetArgumentList()->SetBool(1, true);
|
browser->SendProcessMessage(PID_RENDERER, msg_back);
|
|
}
|
|
void CCef3WebVWndHandler::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
CefRefPtr<CefContextMenuParams> params,
|
CefRefPtr<CefMenuModel> model) {
|
model->Clear();//ûÓв˵¥
|
}
|
|
bool CCef3WebVWndHandler::OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
CefRefPtr<CefRequest> request,
|
bool is_redirect) {
|
CEF_REQUIRE_UI_THREAD();
|
|
//message_router_->OnBeforeBrowse(browser, frame);
|
return false;
|
}
|
|
|
bool CCef3WebVWndHandler::OnOpenURLFromTab(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
const CefString& target_url,
|
CefRequestHandler::WindowOpenDisposition target_disposition,
|
bool user_gesture) {
|
if (target_disposition == WOD_NEW_BACKGROUND_TAB ||
|
target_disposition == WOD_NEW_FOREGROUND_TAB) {
|
// Handle middle-click and ctrl + left-click by opening the URL in a new
|
// browser window.
|
return true;
|
}
|
|
// Open the URL in the current browser window.
|
return false;
|
}
|
|
|
cef_return_value_t CCef3WebVWndHandler::OnBeforeResourceLoad(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
CefRefPtr<CefRequest> request,
|
CefRefPtr<CefRequestCallback> callback) {
|
CEF_REQUIRE_IO_THREAD();
|
|
return resource_manager_->OnBeforeResourceLoad(browser, frame, request, callback);
|
}
|
|
|
CefRefPtr<CefResourceHandler> CCef3WebVWndHandler::GetResourceHandler(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
CefRefPtr<CefRequest> request) {
|
CEF_REQUIRE_IO_THREAD();
|
|
return resource_manager_->GetResourceHandler(browser, frame, request);
|
}
|
|
CefRefPtr<CefResponseFilter> CCef3WebVWndHandler::GetResourceResponseFilter(
|
CefRefPtr<CefBrowser> browser,
|
CefRefPtr<CefFrame> frame,
|
CefRefPtr<CefRequest> request,
|
CefRefPtr<CefResponse> response) {
|
CEF_REQUIRE_IO_THREAD();
|
|
return NULL;
|
//return test_runner::GetResourceResponseFilter(browser, frame, request, response);
|
}
|
|
bool CCef3WebVWndHandler::OnQuotaRequest(CefRefPtr<CefBrowser> browser,
|
const CefString& origin_url,
|
int64 new_size,
|
CefRefPtr<CefRequestCallback> callback) {
|
CEF_REQUIRE_IO_THREAD();
|
|
static const int64 max_size = 1024 * 1024 * 20; // 20mb.
|
|
// Grant the quota request if the size is reasonable.
|
callback->Continue(new_size <= max_size);
|
return true;
|
}
|
|
void CCef3WebVWndHandler::OnProtocolExecution(CefRefPtr<CefBrowser> browser,
|
const CefString& url,
|
bool& allow_os_execution) {
|
CEF_REQUIRE_UI_THREAD();
|
// Allow OS execution of Spotify URIs.
|
allow_os_execution = IsAllowOsExce(url);
|
}
|
|
|
bool CCef3WebVWndHandler::OnCertificateError(
|
CefRefPtr<CefBrowser> browser,
|
ErrorCode cert_error,
|
const CefString& request_url,
|
CefRefPtr<CefSSLInfo> ssl_info,
|
CefRefPtr<CefRequestCallback> callback) {
|
|
CEF_REQUIRE_UI_THREAD();
|
CefRefPtr<CefX509Certificate> cert = ssl_info->GetX509Certificate();
|
CefRefPtr<CefX509CertPrincipal> subject = cert->GetSubject();
|
CefRefPtr<CefX509CertPrincipal> issuer = cert->GetIssuer();
|
|
// Build a table showing certificate information. Various types of invalid
|
// certificates can be tested using https://badssl.com/.
|
std::stringstream ss;
|
ss << "X.509 Certificate Information:"
|
"<table border=1><tr><th>Field</th><th>Value</th></tr>" <<
|
"<tr><td>Subject</td><td>" <<
|
(subject.get() ? subject->GetDisplayName().ToString() : " ") <<
|
"</td></tr>"
|
"<tr><td>Issuer</td><td>" <<
|
(issuer.get() ? issuer->GetDisplayName().ToString() : " ") <<
|
"</td></tr>"
|
"<tr><td>Serial #*</td><td>" <<
|
browser::GetBinaryString(cert->GetSerialNumber()) << "</td></tr>"
|
"<tr><td>Status</td><td>" <<
|
browser::GetCertStatusString(ssl_info->GetCertStatus()) << "</td></tr>"
|
"<tr><td>Valid Start</td><td>" <<
|
browser::GetTimeString(cert->GetValidStart()) << "</td></tr>"
|
"<tr><td>Valid Expiry</td><td>" <<
|
browser::GetTimeString(cert->GetValidExpiry()) << "</td></tr>";
|
|
CefX509Certificate::IssuerChainBinaryList der_chain_list;
|
CefX509Certificate::IssuerChainBinaryList pem_chain_list;
|
cert->GetDEREncodedIssuerChain(der_chain_list);
|
cert->GetPEMEncodedIssuerChain(pem_chain_list);
|
DCHECK_EQ(der_chain_list.size(), pem_chain_list.size());
|
|
der_chain_list.insert(der_chain_list.begin(), cert->GetDEREncoded());
|
pem_chain_list.insert(pem_chain_list.begin(), cert->GetPEMEncoded());
|
|
for (size_t i = 0U; i < der_chain_list.size(); ++i) {
|
ss << "<tr><td>DER Encoded*</td>"
|
"<td style=\"max-width:800px;overflow:scroll;\">" <<
|
browser::GetBinaryString(der_chain_list[i]) << "</td></tr>"
|
"<tr><td>PEM Encoded*</td>"
|
"<td style=\"max-width:800px;overflow:scroll;\">" <<
|
browser::GetBinaryString(pem_chain_list[i]) << "</td></tr>";
|
}
|
|
ss << "</table> * Displayed value is base64 encoded.";
|
|
// Load the error page.
|
LoadWndErrorPage(browser->GetMainFrame(), request_url, cert_error, ss.str());
|
|
return false; // Cancel the request.
|
}
|
|
|
void CCef3WebVWndHandler::OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
|
TerminationStatus status) {
|
CEF_REQUIRE_UI_THREAD();
|
|
|
//message_router_->OnRenderProcessTerminated(browser);
|
|
// Don't reload if there's no start URL, or if the crash URL was specified.
|
if (browser::CCef3MainContext::Get()->GetMainURL().empty() || browser::CCef3MainContext::Get()->GetMainURL() == "chrome://crash")
|
return;
|
|
CefRefPtr<CefFrame> frame = browser->GetMainFrame();
|
std::string url = frame->GetURL();
|
|
// Don't reload if the termination occurred before any URL had successfully
|
// loaded.
|
if (url.empty())
|
return;
|
|
std::string start_url = browser::CCef3MainContext::Get()->GetMainURL();
|
|
// Convert URLs to lowercase for easier comparison.
|
std::transform(url.begin(), url.end(), url.begin(), tolower);
|
std::transform(start_url.begin(), start_url.end(), start_url.begin(),
|
tolower);
|
|
// Don't reload the URL that just resulted in termination.
|
if (url.find(start_url) == 0)
|
return;
|
|
frame->LoadURL(browser::CCef3MainContext::Get()->GetMainURL());
|
}
|
|
bool CCef3WebVWndHandler::IsAllowOsExce(const CefString& url)
|
{
|
std::string urlStr = url;
|
bool bRet = false;
|
if (urlStr.find("spotify:") == 0)
|
bRet= true;
|
else if (urlStr.find("zoommtg:") == 0) //zoomÊÓƵ»áÒéÆô¶¯
|
bRet = true;
|
return bRet;
|
}
|
void CCef3WebVWndHandler::LoadHtml( std::wstring strValue)
|
{
|
|
CefRefPtr<CefFrame> frame;
|
if (m_refBrowser.get())
|
{
|
frame = m_refBrowser->GetMainFrame();
|
}
|
if (frame.get())
|
{
|
m_strHtml = _T("");
|
//std::wstring strHtml;
|
std::wstringstream ss;
|
std::wstring strURL;
|
strURL = _T("http://rendering");
|
ss << _T("<html><body bgcolor=\"white\">")<< strValue <<
|
_T("</body></html>");
|
//strHtml = strValue;
|
frame->LoadString(ss.str(), strURL);
|
//frame->LoadURL(strURL);
|
}
|
else
|
{
|
m_strHtml = strValue;
|
}
|
}
|
} //namespace browser
|
