void ClientHandler::EndTracing() {
if (!CefCurrentlyOn(TID_UI)) {
// Execute on the UI thread.
CefPostTask(TID_UI, base::Bind(&ClientHandler::EndTracing, this));
return;
}
class Client : public CefEndTracingCallback,
public CefRunFileDialogCallback {
public:
explicit Client(CefRefPtr<ClientHandler> handler)
: handler_(handler) {
RunDialog();
}
void RunDialog() {
static const char kDefaultFileName[] = "trace.txt";
std::string path = handler_->GetDownloadPath(kDefaultFileName);
if (path.empty())
path = kDefaultFileName;
// Results in a call to OnFileDialogDismissed.
handler_->GetBrowser()->GetHost()->RunFileDialog(
FILE_DIALOG_SAVE, CefString(), path, std::vector<CefString>(),
this);
}
virtual void OnFileDialogDismissed(
CefRefPtr<CefBrowserHost> browser_host,
const std::vector<CefString>& file_paths) OVERRIDE {
CEF_REQUIRE_UI_THREAD();
if (!file_paths.empty()) {
// File selected. Results in a call to OnEndTracingComplete.
CefEndTracing(file_paths.front(), this);
} else {
// No file selected. Discard the trace data.
CefEndTracing(CefString(), NULL);
}
}
virtual void OnEndTracingComplete(
const CefString& tracing_file) OVERRIDE {
CEF_REQUIRE_UI_THREAD();
handler_->SetLastDownloadFile(tracing_file.ToString());
handler_->SendNotification(NOTIFY_DOWNLOAD_COMPLETE);
}
private:
void ClientHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title) {
CEF_REQUIRE_UI_THREAD();
std::string titleStr(title);
std::cout << "title changed to %s" << titleStr;
}
void PhantomJSHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
ErrorCode errorCode,
const CefString& errorText,
const CefString& failedUrl)
{
CEF_REQUIRE_UI_THREAD();
qCDebug(handler) << browser->GetIdentifier() << isMain(frame) << errorCode << errorText << failedUrl;
if (isMain(frame)) {
handleLoadEnd(browser, errorCode, failedUrl, false);
}
// Don't display an error for downloaded files.
if (errorCode == ERR_ABORTED)
return;
// Display a load error message.
std::stringstream ss;
ss << "<html><body bgcolor=\"white\">"
"<h2>Failed to load URL " << std::string(failedUrl) <<
" with error " << std::string(errorText) << " (" << errorCode <<
").</h2></body></html>";
frame->LoadString(ss.str(), failedUrl);
}
void PhantomJSHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser)
{
CEF_REQUIRE_UI_THREAD();
qCDebug(handler) << browser->GetIdentifier();
auto& browserInfo = m_browsers[browser->GetIdentifier()];
browserInfo.browser = browser;
if (!m_popupToParentMapping.isEmpty()) {
auto parentBrowser = m_popupToParentMapping.dequeue();
// we don't open about:blank for popups
browserInfo.firstLoadFinished = true;
emitSignal(m_browsers.value(parentBrowser).browser, QStringLiteral("onPopupCreated"),
{browser->GetIdentifier()}, true);
}
#if CHROME_VERSION_BUILD >= 2526
if (PRINT_SETTINGS) {
auto prefs = browser->GetHost()->GetRequestContext()->GetAllPreferences(true);
CefDictionaryValue::KeyList keys;
prefs->GetKeys(keys);
for (const auto& key : keys) {
printValue(key, prefs->GetValue(key));
}
}
#endif
}
bool CWebClient::OnContextMenuCommand(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefContextMenuParams> params,
int command_id,
EventFlags event_flags) {
CEF_REQUIRE_UI_THREAD();
switch (command_id) {
case CLIENT_ID_SHOW_DEVTOOLS:
ShowDevTools(this, browser, CefPoint());
return true;
case CLIENT_ID_CLOSE_DEVTOOLS:
CloseDevTools(browser);
return true;
case CLIENT_ID_INSPECT_ELEMENT:
ShowDevTools(this, browser, CefPoint(params->GetXCoord(), params->GetYCoord()));
return true;
case CLIENT_ID_RELOAD:
RefreshPage(browser, true);
return true;
default: // Allow default handling, if any.
return false;
}
}
void CefClientImpl::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
CEF_REQUIRE_UI_THREAD();
if (GetBrowserId() == browser->GetIdentifier())
{
base::AutoLock lock_scope(lock_);
// Free the browser pointer so that the browser can be destroyed
browser_child = NULL;
}
else if(browser->IsPopup())
{
// Remove from the browser popup list.
BrowserList::iterator bit = popup_browsers_.begin();
for (; bit != popup_browsers_.end(); ++bit) {
if ((*bit)->IsSame(browser)) {
popup_browsers_.erase(bit);
break;
}
}
}
if (--browser_count_ == 0) {
// All browser windows have closed.
// Remove and delete message router handlers.
message_router_ = NULL;
// Quit the application message loop.
PostMessage(hMessageWnd,WM_COMMAND,ID_QUIT,0);
}
}
void SimpleHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title) {
CEF_REQUIRE_UI_THREAD();
CefWindowHandle hwnd = browser->GetHost()->GetWindowHandle();
SetWindowText(hwnd, std::wstring(title).c_str());
}
/*virtual*/ void CWebClient::OnBeforeClose(CefRefPtr<CefBrowser> browser) /*OVERRIDE*/
{
CEF_REQUIRE_UI_THREAD();
base::AutoLock lock_scope(lock_);
if (main_browser_.get() && main_browser_->GetIdentifier() == browser->GetIdentifier())
{
main_browser_ = NULL;
for (auto bit = browsers_list_.begin(); bit != browsers_list_.end(); ++bit) {
if ((*bit)->IsLoading())
(*bit)->StopLoad();
(*bit)->GetHost()->CloseBrowser(true);
}
}
else
{
browsers_list_.erase(
std::remove_if(browsers_list_.begin(), browsers_list_.end(), [&](BrowserList::value_type & it){
return it->GetIdentifier() == browser->GetIdentifier();
}),
browsers_list_.end()
);
}
// if (!main_browser_ && browsers_list_.empty())
// {
// HWND hwnd = AfxGetMainWnd()->GetSafeHwnd();
// PostMessage(hwnd, WM_CLOSE, 0, 0);
// }
return;
}
void ClientHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
ErrorCode errorCode,
const CefString& errorText,
const CefString& failedUrl) {
CEF_REQUIRE_UI_THREAD();
// Don't display an error for downloaded files.
if (errorCode == ERR_ABORTED)
return;
// Don't display an error for external protocols that we allow the OS to
// handle. See OnProtocolExecution().
if (errorCode == ERR_UNKNOWN_URL_SCHEME) {
std::string urlStr = frame->GetURL();
if (urlStr.find("spotify:") == 0)
return;
}
// Display a load error message.
std::stringstream ss;
ss << "<html><body bgcolor=\"white\">"
"<h2>Failed to load URL " << std::string(failedUrl) <<
" with error " << std::string(errorText) << " (" << errorCode <<
").</h2></body></html>";
frame->LoadString(ss.str(), failedUrl);
}
void ClientHandler::OnPopupShow(CefRefPtr<CefBrowser> browser,
bool show) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return;
return osr_handler_->OnPopupShow(browser, show);
}
void CWebClient::OnBeforeContextMenu(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefContextMenuParams> params,
CefRefPtr<CefMenuModel> model) {
CEF_REQUIRE_UI_THREAD();
if ((params->GetTypeFlags() & (CM_TYPEFLAG_PAGE | CM_TYPEFLAG_FRAME)) != 0) {
// Add a separator if the menu already has items.
if (model->GetCount() > 0)
model->AddSeparator();
// Add DevTools items to all context menus.
model->AddItem(CLIENT_ID_SHOW_DEVTOOLS, "&Show DevTools");
model->AddItem(CLIENT_ID_CLOSE_DEVTOOLS, "Close DevTools");
model->AddSeparator();
model->AddItem(CLIENT_ID_INSPECT_ELEMENT, "Inspect Element");
// Test context menu features.
//BuildTestMenu(model);
model->AddSeparator();
model->AddItem(CLIENT_ID_RELOAD, "&Reload");
}
}
void ClientHandler::OnCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return;
osr_handler_->OnCursorChange(browser, cursor);
}
void ClientHandler::OnPopupSize(CefRefPtr<CefBrowser> browser,
const CefRect& rect) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return;
return osr_handler_->OnPopupSize(browser, rect);
}
void ClientHandler::UpdateDragCursor(CefRefPtr<CefBrowser> browser,
CefRenderHandler::DragOperation operation) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return;
osr_handler_->UpdateDragCursor(browser, operation);
}
bool ClientHandler::DoClose(CefRefPtr<CefBrowser> browser) {
CEF_REQUIRE_UI_THREAD();
// Closing the main window requires special handling. See the DoClose()
// documentation in the CEF header for a detailed destription of this
// process.
if (GetBrowserId() == browser->GetIdentifier()) {
if (!popup_browsers_.empty()) {
// Request that any popup browsers close.
BrowserList::const_iterator it = popup_browsers_.begin();
for (; it != popup_browsers_.end(); ++it)
(*it)->GetHost()->CloseBrowser(true);
}
base::AutoLock lock_scope(lock_);
// Set a flag to indicate that the window close should be allowed.
is_closing_ = true;
developerStudioProcess->StopProcess();
}
// Allow the close. For windowed browsers this will result in the OS close
// event being sent.
return false;
}
bool ClientHandler::GetScreenInfo(CefRefPtr<CefBrowser> browser,
CefScreenInfo& screen_info) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return false;
return osr_handler_->GetScreenInfo(browser, screen_info);
}
bool ClientHandler::GetRootScreenRect(CefRefPtr<CefBrowser> browser,
CefRect& rect) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return false;
return osr_handler_->GetRootScreenRect(browser, rect);
}
bool ClientHandler::OnBeforeUnloadDialog(
CefRefPtr<CefBrowser> browser,
const CefString& message_text,
bool is_reload,
CefRefPtr<CefJSDialogCallback> callback) {
CEF_REQUIRE_UI_THREAD();
return false;
}
void ClientHandler::SetLoading(bool isLoading) {
CEF_REQUIRE_UI_THREAD();
if (isLoading)
gtk_widget_set_sensitive(GTK_WIDGET(stop_handle_), true);
else
gtk_widget_set_sensitive(GTK_WIDGET(stop_handle_), false);
}
// CefLifeSpanHandler
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override
{
CEF_REQUIRE_UI_THREAD();
if (!owner_.on_cef_after_created(browser)) {
browser_list_.push_back(browser);
}
}
bool PhantomJSHandler::DoClose(CefRefPtr<CefBrowser> browser)
{
CEF_REQUIRE_UI_THREAD();
// Allow the close. For windowed browsers this will result in the OS close
// event being sent.
return false;
}
void BrowserClient::OnBeforeClose(CefRefPtr<CefBrowser> browser)
{
CEF_REQUIRE_UI_THREAD();
if (m_BrowserId == browser->GetIdentifier())
{
m_Browser = NULL;
}
}
void CefClientImpl::OnLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
ErrorCode errorCode,
const CefString& errorText,
const CefString& failedUrl) {
CEF_REQUIRE_UI_THREAD();
}
void ClientHandler::OnResetDialogState(CefRefPtr<CefBrowser> browser) {
CEF_REQUIRE_UI_THREAD();
if (!gtk_dialog_)
return;
gtk_widget_destroy(gtk_dialog_);
gtk_dialog_ = NULL;
js_dialog_callback_ = NULL;
}
bool ClientHandler::StartDragging(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefDragData> drag_data,
CefRenderHandler::DragOperationsMask allowed_ops,
int x, int y) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return false;
return osr_handler_->StartDragging(browser, drag_data, allowed_ops, x, y);
}
void ClientHandler::OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
bool isLoading,
bool canGoBack,
bool canGoForward) {
CEF_REQUIRE_UI_THREAD();
SetLoading(isLoading);
SetNavState(canGoBack, canGoForward);
}
void ClientHandler::OnCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor,
CursorType type,
const CefCursorInfo& custom_cursor_info) {
CEF_REQUIRE_UI_THREAD();
if (!osr_handler_.get())
return;
osr_handler_->OnCursorChange(browser, cursor, type, custom_cursor_info);
}
bool ClientHandler::OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
bool is_redirect) {
CEF_REQUIRE_UI_THREAD();
message_router_->OnBeforeBrowse(browser, frame);
return false;
}
void CefClientImpl::OnBeforeContextMenu(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefContextMenuParams> params,
CefRefPtr<CefMenuModel> model) {
CEF_REQUIRE_UI_THREAD();
//http://blog.sina.com.cn/s/blog_dad2c54101019cwb.html
model->Clear();//Çå³ýÓÒ¼ü²Ëµ¥
}
void BrowserClient::OnAfterCreated(CefRefPtr<CefBrowser> browser)
{
CEF_REQUIRE_UI_THREAD();
if (!m_Browser.get())
{
// Keep a reference to the main browser.
m_Browser = browser;
m_BrowserId = browser->GetIdentifier();
}
}
