I tried to use cef_message_router library for our POC.
I used EXAMPLE_USAGE from cef_message_router.h as a guide.
For some reason OnQuery method is not called.
From JS I get always error_code=-1 & error_message="The query has been canceled"
PSB JavaScript & C++ code
Please advice,
THANK YOU,
ariel
JavaScript
- Code: Select all
var request_id = window.cefQuery({
request: 'my_request',
persistent: false,
onSuccess: function (responce) {window.alert ("got success from c++" + responce);},
onFailure: function (error_code, error_message) {window.alert ("got failure from c++" + " " + error_code + "err_msg " + err);}
C++ (In scope of POC I've added my code in client_app_browser.cc)
- Code: Select all
#include "cefclient/browser/client_app_browser.h"
#include "include/base/cef_logging.h"
#include "include/cef_cookie.h"
void SetRouterConfig(CefMessageRouterConfig& config) {
config.js_query_function = "cefQuery";
config.js_cancel_function = "cefQueryCancel";
}
class Handler : public CefMessageRouterBrowserSide::Handler {
public:
Handler(){}
protected:
bool OnQuery(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int64 query_id,
const CefString& request,
bool persistent,
CefRefPtr<Callback> callback) OVERRIDE {
/*int num1=500;
int num2 = 0;
int num3;
num3=num1/num2;*/
const char QueryResponse[] = "success_response";
callback->Success(QueryResponse);
return true;
}
void OnQueryCanceled(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int64 query_id) OVERRIDE {}
};
namespace client {
MyClientApp::MyClientApp() {
}
//Browser process methods
void MyClientApp::OnContextInitialized() {
CreateDelegates(delegates_);
// Register cookieable schemes with the global cookie manager.
CefRefPtr<CefCookieManager> manager =
CefCookieManager::GetGlobalManager(NULL);
DCHECK(manager.get());
manager->SetSupportedSchemes(cookieable_schemes_, NULL);
print_handler_ = CreatePrintHandler();
DelegateSet::iterator it = delegates_.begin();
for (; it != delegates_.end(); ++it)
(*it)->OnContextInitialized(this);
CefMessageRouterConfig config;
SetRouterConfig(config);
message_browser_router_ = CefMessageRouterBrowserSide::Create(config);
CefMessageRouterBrowserSide::Handler* myHandler_ = new Handler();
bool status;
// adding status only in order to get runtime error , which will proof that AddHandler worked ok)
status = message_browser_router_->AddHandler(myHandler_,true);
if (!status) {
int num1=500;
int num2 = 0;
int num3;
num3=num1/num2;
}
}
...
...
//Render process methods
void MyClientApp::OnWebKitInitialized() {
CefMessageRouterConfig config;
SetRouterConfig(config);
message_render_router_ = CefMessageRouterRendererSide::Create(config);
DelegateSet::iterator it = delegates_.begin();
for (; it != delegates_.end(); ++it)
(*it)->OnWebKitInitialized(this);
}
....
....
client_app_browser.h
- Code: Select all
#include <set>
#include "cefclient/common/client_app.h"
#include "include/cef_process_message.h"
#include "include/wrapper/cef_message_router.h"
namespace client {
// Client app implementation for the browser process.
class MyClientApp : public ClientApp,
public CefRenderProcessHandler,
public CefBrowserProcessHandler {
public:
// Interface for browser & render delegates. All Delegates must be returned via
// CreateDelegates. Do not perform work in the Delegate
// constructor. See CefBrowserProcessHandler & CefRenderProcessHandler for documentation.
CefMessageRouterConfig config;
CefRefPtr<CefMessageRouterBrowserSide> message_browser_router_;
CefRefPtr<CefMessageRouterRendererSide> message_render_router_;
class Delegate : public virtual CefBase {
public:
//Ariel: browser delegates
virtual void OnContextInitialized(CefRefPtr<ClientApp> app) {}
virtual void OnBeforeChildProcessLaunch(
CefRefPtr<MyClientApp> app,
CefRefPtr<CefCommandLine> command_line) {}
virtual void OnRenderProcessThreadCreated(
CefRefPtr<MyClientApp> app,
CefRefPtr<CefListValue> extra_info) {}
//Ariel: renderer delegates
virtual void OnRenderThreadCreated(CefRefPtr<MyClientApp> app,
CefRefPtr<CefListValue> extra_info) {}
virtual void OnWebKitInitialized(CefRefPtr<MyClientApp> app) {}
virtual void OnBrowserCreated(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser) {}
virtual void OnBrowserDestroyed(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser) {}
virtual CefRefPtr<CefLoadHandler> GetLoadHandler(
CefRefPtr<MyClientApp> app) {
return NULL;
}
virtual bool OnBeforeNavigation(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
cef_navigation_type_t navigation_type,
bool is_redirect) {
return false;
}
virtual void OnContextCreated(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) {}
virtual void OnContextReleased(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) {}
virtual void OnUncaughtException(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context,
CefRefPtr<CefV8Exception> exception,
CefRefPtr<CefV8StackTrace> stackTrace) {}
virtual void OnFocusedNodeChanged(CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefDOMNode> node) {}
// Called when a process message is received. Return true if the message was
// handled and should not be passed on to other handlers. Delegates
// should check for unique message names to avoid interfering with each
// other.
virtual bool OnProcessMessageReceived(
CefRefPtr<MyClientApp> app,
CefRefPtr<CefBrowser> browser,
CefProcessId source_process,
CefRefPtr<CefProcessMessage> message) {
return false;
}
};
typedef std::set<CefRefPtr<Delegate> > DelegateSet;
MyClientApp();
private:
// Creates all of the Delegate objects. Implemented by cefclient in
// client_app_delegates_browser.cc
static void CreateDelegates(DelegateSet& delegates);
// Create the Linux print handler. Implemented by cefclient in
// client_app_delegates_browser.cc
static CefRefPtr<CefPrintHandler> CreatePrintHandler();
// CefApp methods.
CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() OVERRIDE {
return this;
}
CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() OVERRIDE {
return this;
}
// CefBrowserProcessHandler methods.
void OnContextInitialized() OVERRIDE;
void OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line) OVERRIDE;
void OnRenderProcessThreadCreated(
CefRefPtr<CefListValue> extra_info) OVERRIDE;
CefRefPtr<CefPrintHandler> GetPrintHandler() OVERRIDE {return print_handler_;}
// CefRenderProcessHandler methods.
void OnRenderThreadCreated(CefRefPtr<CefListValue> extra_info) OVERRIDE;
void OnWebKitInitialized() OVERRIDE;
void OnBrowserCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
void OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) OVERRIDE;
CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE;
bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
NavigationType navigation_type,
bool is_redirect) OVERRIDE;
void OnContextCreated(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) OVERRIDE;
void OnContextReleased(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) OVERRIDE;
void OnUncaughtException(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context,
CefRefPtr<CefV8Exception> exception,
CefRefPtr<CefV8StackTrace> stackTrace) OVERRIDE;
void OnFocusedNodeChanged(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefDOMNode> node) OVERRIDE;
bool OnProcessMessageReceived(
CefRefPtr<CefBrowser> browser,
CefProcessId source_process,
CefRefPtr<CefProcessMessage> message) OVERRIDE;
// Set of supported Delegates.
DelegateSet delegates_;
CefRefPtr<CefPrintHandler> print_handler_;
IMPLEMENT_REFCOUNTING(MyClientApp);
DISALLOW_COPY_AND_ASSIGN(MyClientApp);
};
} // namespace client
#endif // CEF_TESTS_CEFCLIENT_BROWSER_CLIENT_APP_BROWSER_H_