OnQuery method is not called

[ari37086]

Hi Marshall,

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_


[magreenblatt]

You don't appear to be calling the CefMessageRouter methods from your handler implementation.

For CefMessageRouterBrowserSide: https://bitbucket.org/chromiumembedded/ ... ter#cl-328
For CefMessageRouterRendererSide: https://bitbucket.org/chromiumembedded/ ... ter#cl-393

[ari37086]

I'm not sure I understand.
Do you mean that:
1) there are some methods , that I do not call ?
2) Or methods I call like create or AddHandler are called from the wrong places ?
3) Both ?
4) something else ?

[ari37086]

actually , by adding few LOG prints I found out that OnAfterCreated method (the override of original function) (the place I call to AddHandler) is not called.

Code: Select all

class SimpleApp: public CefClient,
                public CefLifeSpanHandler,
                                         ...
                                         ... {

 public:
      CefRefPtr<CefMessageRouterBrowserSide>  message_browser_router_;
      CefRefPtr<CefMessageRouterRendererSide> message_render_router_;

  SimpleApp();


  // CefApp methods:
  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
      OVERRIDE { return this; }
  virtual CefRefPtr<CefRenderProcessHandler>  GetRenderProcessHandler()
    OVERRIDE { return this; }
 
  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler()
     OVERRIDE { return this; }

  // CefBrowserProcessHandler method:
  virtual void OnContextInitialized() OVERRIDE;

  //CefLifeSpanHandler method
 
  void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;

....
...


Code: Select all

void SimpleApp::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
   LOG(ERROR) << "+++: OnAfterCreated entered" ;
....


Any Ideas ?

[magreenblatt]

CefApp and CefClient are two different interfaces. You need to implement the Get*Handler() methods as appropriate to the interface. Similarly, you need to call CefMessageRouter methods from Handler implementations as documented in the above links.

[ari37086]

I resolved the problem of OnAfterCreated callback not called by moving direct call toCefBrowserHost::CreateBrowser from OnContextcInitialized callback to SimpleApp::CreateBrowser, which I added specially for this call.

Now return back to issue "OnQuery method is not called" just it looks a little bit different. No "-1" error code and error message are returned. But it seems to be stack.
LOG message I added to OnQuery method is not printed and runtime error code I added to OnQuery method to get application crash not run ....so .... I guess that this callback still not called

Below is the code of SimpleApp I use for this POC. I'll appreciate it very very very much if you could take a look and tell me if I missed something. in this stage I want only to see that OnQuery callback is called , so I removed all code that is not relevant for it.

1) SimpleApp::OnContextInitialized --> SimpleApp code NO CHANGES HERE ,besides of URL change and call to CreateBrowser
2) SimpleApp::OnAfterCreated --> CREATE message_browser_router AND CALL TO AddHandler (get TRUE from AddHandler)
3) SimpleApp::OnContextCreated --> ADDED SIMPLE JS script binding , just to be sure that this callback is called (LOG messages are not printed)
4) SimpleApp::OnWebKitInitialized --> CREATE message_render_router HOPE that this called , even if LOG is not printed
5) SimpleApp::OnQuery --> Definition of OnQuery callback added LOG and code that suppose to cause runtime error just in order to get
proof that it called

Code: Select all

void SetRouterConfig(CefMessageRouterConfig& config) {
  config.js_query_function = "cefQuery";
  config.js_cancel_function = "cefQueryCancel";
}

       
SimpleApp::SimpleApp() {
}

void SimpleApp::OnContextInitialized() {                 
  CEF_REQUIRE_UI_THREAD();

  // Information used when creating the native window.
  CefWindowInfo window_info;

#if defined(OS_WIN)
  // On Windows we need to specify certain flags that will be passed to
  // CreateWindowEx().
  window_info.SetAsPopup(NULL, "cefsimple");
#endif

  // Specify CEF browser settings here.
  CefBrowserSettings browser_settings;

  std::string url;

  // Check if a "--url=" value was provided via the command-line. If so, use
  // that instead of the default URL.
  CefRefPtr<CefCommandLine> command_line =
      CefCommandLine::GetGlobalCommandLine();
  url = command_line->GetSwitchValue("url");
  if (url.empty())
    url="https://genesis_wb_34047:3000/#";

  // Create the first browser window.

  //CefBrowserHost::CreateBrowser(window_info, handler.get(), url,  browser_settings, NULL);
 
  CreateBrowser(url);
 
  LOG(ERROR) << "Ariel_simple_app: OncontexInitialized run" ;
 
}

void SimpleApp::OnAfterCreated(CefRefPtr<CefBrowser> browser) {         
   LOG(ERROR) << "Ariel_simple_app: OnAfterCreated entered" ;
   bool status=false;

   if (!message_browser_router_.get()) {
     // Create the browser-side router for query handling.
     CefMessageRouterConfig config;
     SetRouterConfig(config);
     message_browser_router_ = CefMessageRouterBrowserSide::Create(config);
    
     myHandler_ = new Handler();
      // adding status only in order to get runtime error , which will proof that AddHandler worked ok)
     status = message_browser_router_->AddHandler(myHandler_,true);

     //status=message_browser_router_->AddHandler(this, false);
     if (!status) {    
        LOG(ERROR) << "Ariel_simple_app: AddHandler return false" ;
      }
     else {
        LOG(ERROR) << "Ariel_simple_app: AddHandler return true" ;
        }

   }
    
  }

 void SimpleApp::OnContextCreated(CefRefPtr<CefBrowser> browser,
                        CefRefPtr<CefFrame> frame,
                        CefRefPtr<CefV8Context> context)  {
   CefRefPtr<CefV8Value> object = context->GetGlobal();

 
 /*********************************************************************/
   // Create a new V8 string value. See the "Basic JS Types" section below.
    
   CefRefPtr<CefV8Value> str = CefV8Value::CreateString("Hello Dear Ariel !!!");
   CefRefPtr<CefV8Value> num = CefV8Value::CreateInt(rand());
   CefTime date;
   CefRefPtr<CefV8Value> time = CefV8Value::CreateDate(date);
   
   
   CefMessageRouterConfig config;
   SetRouterConfig(config);
   message_render_router_ = CefMessageRouterRendererSide::Create(config);
 
  /*********************************************************************/
   object->SetValue("test", str, V8_PROPERTY_ATTRIBUTE_NONE);
    LOG(ERROR) << "Ariel_simple_app: OnContextCreated entered" ;
 
   
   //object->SetValue("test", num, V8_PROPERTY_ATTRIBUTE_NONE);
}

void SimpleApp::OnWebKitInitialized() {     
  LOG(ERROR) << "Ariel_simple_app: OnWebKitInitialized entered" ;
  CefMessageRouterConfig config;
  SetRouterConfig(config);
  message_render_router_ = CefMessageRouterRendererSide::Create(config);
   
}

bool SimpleApp::OnQuery(CefRefPtr<CefBrowser> browser,
          CefRefPtr<CefFrame> frame,
          int64 query_id,
          const CefString& request,
          bool persistent,
          CefRefPtr<Callback> callback)  {                                                                                           
         
   LOG(ERROR) << "Ariel_simple_app: OnQuery entered" ;
   

         //if (request == "my_request"){
            int num1=500;
            int num2 = 0;
            int num3;
            num3=num1/num2;

         //   return true;
         //}
          const char QueryResponse[] = "success_response";
          callback->Success(QueryResponse);

          return true;
         
}
void SimpleApp::CreateBrowser(
    const CefString& url,
    CefRefPtr<CefRequestContext> request_context) {
  CefWindowInfo windowInfo;
  CefBrowserSettings settings;
#if defined(OS_WIN)
  windowInfo.SetAsPopup(NULL, "Ariel POC");
  //windowInfo.style |= WS_VISIBLE;
#endif
  CefBrowserHost::CreateBrowser(windowInfo, this, url, settings,
                                request_context);
}

bool SimpleApp::OnProcessMessageReceived(                                               //Have no idea if this code is called , as there are 
                                                                                                                  // no LOG prints
    CefRefPtr<CefBrowser> browser,
    CefProcessId source_process,
    CefRefPtr<CefProcessMessage> message) {
   LOG(ERROR) << "Ariel_simple_app: OnProcessMessageReceived entered" ;

  bool res;
  res=  message_browser_router_->OnProcessMessageReceived(
      browser, source_process,  message);
  if (res) {
     LOG(ERROR) << "Ariel_simple_app: OnProcessMessageReceived res=true" ;     
     }
  else {
     LOG(ERROR) << "Ariel_simple_app: OnProcessMessageReceived res=false" ;     
     }
  return res;
}




Code: Select all

// Copyright (c) 2013 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.

#ifndef CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_
#define CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_

#include "include/cef_app.h"
#include "include/cef_process_message.h"
#include "include/wrapper/cef_message_router.h"
#include "include/cef_life_span_handler.h"
#include "include/cef_client.h"

#include "include/cef_v8.h"

class SimpleApp : public CefClient,
                public CefLifeSpanHandler,
                public CefApp,
                public CefMessageRouterBrowserSide::Handler,
                public CefRenderProcessHandler,
                     public CefBrowserProcessHandler {

 public:
      CefRefPtr<CefMessageRouterBrowserSide>  message_browser_router_;
     CefRefPtr<CefMessageRouterRendererSide> message_render_router_;
     CefMessageRouterBrowserSide::Handler* myHandler_;

  SimpleApp();


  // CefApp methods:
  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
      OVERRIDE { return this; }
  virtual CefRefPtr<CefRenderProcessHandler>  GetRenderProcessHandler()
    OVERRIDE { return this; }
 
  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler()
     OVERRIDE { return this; }

  // CefBrowserProcessHandler method:
  virtual void OnContextInitialized() OVERRIDE;

  //CefLifeSpanHandler method
 
  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser)OVERRIDE;

  //CefRenderProcessHandler methods;
 
  virtual void OnWebKitInitialized() OVERRIDE;
 
  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
                          CefRefPtr<CefFrame> frame,
                          CefRefPtr<CefV8Context> context) OVERRIDE ;

  //CefMessageRouterBrowserSide::Handler methods
  bool OnQuery(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int64 query_id,
                  const CefString& request,
                  bool persistent,
                  CefRefPtr<Callback> callback) OVERRIDE ;

  void CreateBrowser(const CefString& url,
                     CefRefPtr<CefRequestContext> request_context = NULL);


 // Returns true if the router handled the navigation.
  bool OnProcessMessageReceived(
      CefRefPtr<CefBrowser> browser,
      CefProcessId source_process,
      CefRefPtr<CefProcessMessage> message) override;
      
   
   // Include the default reference counting implementation.
  IMPLEMENT_REFCOUNTING(SimpleApp);
};

#endif  // CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_


[magreenblatt]

You should not implement both CefApp and CefClient in the same instance. They are used for totally different purposes. Have you looked at any of the sample applications? You can start with https://bitbucket.org/chromiumembedded/ ... i/Tutorial.

[ari37086]

of course I looked in the sample applications and red Tutorial , actually this is what I'm doing for the last few weeks - read Tutorial and "play" with sample applications. (I was asked to find a solution for our project and I almost sure that CEF will be great for us)

I didn't want to write the application from scratch, and I don't need something complicated (no forward-backward-multiple tabs)
SimpleApp which implement CefApp is just perfect for me.
BUT I want to use Handler's like CefLifeSpanHandler, which is part of CefClient interface.

1) what is the solution ?
2) why I can implement both in the same instance ?
3) is this a reason that OnQuery callback is not called ?


thanks a lot for your help

[ari37086]

I found the reason of the problem and OnQuery is working great now.
If it could be useful for someone I'll summarize it shortly below.

1) try1Implementation in Simple_app didn't work --> because of what Marshall answered before, I tried to integrate to interfaces in same application. this was wrong.

2) try2Tried to add this to CliEntAppBrowser app (client_app_browser.cc) . Added everything according to guidelines in cef_message_router.h , BUT it still didn't work. Using LOG prints I found out that instead of calling OnAfterCreated & OnProcessMessageReceived that I defined, applications call to those what were defined in ClientHandler

finally I deleted from cefclient_win.cc

// Create the first window.
context->GetRootWindowManager()->CreateRootWindow(
true, // Show controls.
settings.windowless_rendering_enabled ? true : false,
CefRect(), // Use default system size.
std::string()); // Use default URL.

added CreateBrowser in OnContextInitialized callback.

[roysumit1309]

Can you summarize the steps for using cefQuery for cefsimple.