Override of pure virtual function compiles but does not carry out task
<p>What is the best way to call the following function from my main function(shown below)?</p>

<p>Everything compiles but the "SetReferrer method"  I reference in a custom class does not work.  I am calling a custom MyResourceHandler class from the below function but I do not think the function is being called form my main function.</p>

<p>How to call this function from my main function?</p>

<pre><code>virtual CefRefPtr&lt;CefResourceHandler&gt; GetResourceHandler(
      CefRefPtr&lt;CefBrowser&gt; browser,
      CefRefPtr&lt;CefFrame&gt; frame,
      CefRefPtr&lt;CefRequest&gt; request) {

    //return NULL;
    return new MyResourceHandler();
</code></pre>

<p>}</p>

<p>The SetReferrer method,(in CefRequest class),  I am referencing from  method in the custom MyResourceHandler class:</p>

<pre><code>virtual void SetReferrer(const CefString&amp; referrer_url,
                           ReferrerPolicy policy) =0;
</code></pre>

<p>The pure virtual function I override to reference the SetReferrer method from:</p>

<pre><code> bool ProcessRequest(CefRefPtr&lt;CefRequest&gt; request,
                              CefRefPtr&lt;CefCallback&gt; callback) {

    CefRefPtr&lt;CefRequest&gt; cef   = CefRequest::Create();
    request = cef;
    CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS;
    request-&gt;SetReferrer("www.google.com",origin);
    return true;
    //cef-&gt;SetReferrer("www.google.com",origin);};
};
</code></pre>

<p>My custom class that is called from the function above:</p>

<pre><code>class MyResourceHandler : public CefResourceHandler
{
public:
MyResourceHandler()
//offset_(0)
{}

  bool ProcessRequest(CefRefPtr&lt;CefRequest&gt; request,
                              CefRefPtr&lt;CefCallback&gt; callback) {

    CefRefPtr&lt;CefRequest&gt; cef   = CefRequest::Create();
    request = cef;
    CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS;
    request-&gt;SetReferrer("www.google.com",origin);
    return true;
    //cef-&gt;SetReferrer("www.google.com",origin);};
};

   void GetResponseHeaders(CefRefPtr&lt;CefResponse&gt; response,
                                  int64&amp; response_length,
                                  CefString&amp; redirectUrl) ;


   bool ReadResponse(void* data_out,
                            int bytes_to_read,
                            int&amp; bytes_read,
                            CefRefPtr&lt;CefCallback&gt; callback) ;

  bool CanGetCookie(const CefCookie&amp; cookie) { return true; }


   bool CanSetCookie(const CefCookie&amp; cookie) { return true; }


   void Cancel() ;

   void AddRef()const {} ;

bool Release() const { return true; }

 bool HasOneRef() const { return true; };
};
</code></pre>

<p>Class that contains the method I am using:</p>

<pre><code>#ifndef CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
#define CEF_INCLUDE_CEF_REQUEST_HANDLER_H_
#pragma once

#include "include/cef_auth_callback.h"
#include "include/cef_base.h"
#include "include/cef_browser.h"
#include "include/cef_frame.h"
#include "include/cef_resource_handler.h"
#include "include/cef_response.h"
#include "include/cef_response_filter.h"
#include "include/cef_request.h"
#include "include/cef_ssl_info.h"


///
// Callback interface used for asynchronous continuation of url requests.
///
/*--cef(source=library)--*/
class CefRequestCallback : public virtual CefBase {
 public:
  ///
  // Continue the url request. If |allow| is true the request will be continued.
  // Otherwise, the request will be canceled.
  ///
  /*--cef(capi_name=cont)--*/
  virtual void Continue(bool allow) =0;

  ///
  // Cancel the url request.
  ///
  /*--cef()--*/
  virtual void Cancel() =0;
};


///
// Implement this interface to handle events related to browser requests. The
// methods of this class will be called on the thread indicated.
///
/*--cef(source=client)--*/
class CefRequestHandler : public virtual CefBase {
 public:
  typedef cef_return_value_t ReturnValue;
  typedef cef_termination_status_t TerminationStatus;
  typedef cef_urlrequest_status_t URLRequestStatus;
  typedef cef_window_open_disposition_t WindowOpenDisposition;

  ///
  // Called on the UI thread before browser navigation. Return true to cancel
  // the navigation or false to allow the navigation to proceed. The |request|
  // object cannot be modified in this callback.
  // CefLoadHandler::OnLoadingStateChange will be called twice in all cases.
  // If the navigation is allowed CefLoadHandler::OnLoadStart and
  // CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled
  // CefLoadHandler::OnLoadError will be called with an |errorCode| value of
  // ERR_ABORTED.
  ///
  /*--cef()--*/
  virtual bool OnBeforeBrowse(CefRefPtr&lt;CefBrowser&gt; browser,
                              CefRefPtr&lt;CefFrame&gt; frame,
                              CefRefPtr&lt;CefRequest&gt; request,
                              bool is_redirect) {
    return false;
  }

  ///
  // Called on the UI thread before OnBeforeBrowse in certain limited cases
  // where navigating a new or different browser might be desirable. This
  // includes user-initiated navigation that might open in a special way (e.g.
  // links clicked via middle-click or ctrl + left-click) and certain types of
  // cross-origin navigation initiated from the renderer process (e.g.
  // navigating the top-level frame to/from a file URL). The |browser| and
  // |frame| values represent the source of the navigation. The
  // |target_disposition| value indicates where the user intended to navigate
  // the browser based on standard Chromium behaviors (e.g. current tab,
  // new tab, etc). The |user_gesture| value will be true if the browser
  // navigated via explicit user gesture (e.g. clicking a link) or false if it
  // navigated automatically (e.g. via the DomContentLoaded event). Return true
  // to cancel the navigation or false to allow the navigation to proceed in the
  // source browser's top-level frame.
  ///
  /*--cef()--*/
  virtual bool OnOpenURLFromTab(CefRefPtr&lt;CefBrowser&gt; browser,
                                CefRefPtr&lt;CefFrame&gt; frame,
                                const CefString&amp; target_url,
                                WindowOpenDisposition target_disposition,
                                bool user_gesture) {
    return false;
  }

  ///
  // Called on the IO thread before a resource request is loaded. The |request|
  // object may be modified. Return RV_CONTINUE to continue the request
  // immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback::
  // Continue() at a later time to continue or cancel the request
  // asynchronously. Return RV_CANCEL to cancel the request immediately.
  //
  ///
  /*--cef(default_retval=RV_CONTINUE)--*/
  virtual ReturnValue OnBeforeResourceLoad(
      CefRefPtr&lt;CefBrowser&gt; browser,
      CefRefPtr&lt;CefFrame&gt; frame,
      CefRefPtr&lt;CefRequest&gt; request,
      CefRefPtr&lt;CefRequestCallback&gt; callback) {
    return RV_CONTINUE;

  }

  ///
  // Called on the IO thread before a resource is loaded. To allow the resource
  // to load normally return NULL. To specify a handler for the resource return
  // a CefResourceHandler object. The |request| object should not be modified in
  // this callback.
  ///
  /*--cef()--*/
  virtual CefRefPtr&lt;CefResourceHandler&gt; GetResourceHandler(
      CefRefPtr&lt;CefBrowser&gt; browser,
      CefRefPtr&lt;CefFrame&gt; frame,
      CefRefPtr&lt;CefRequest&gt; request) {

    //return NULL;
    return new MyResourceHandler();
    //new MyResourceHandler();
  }

class MyResourceHandler : public CefResourceHandler
{
public:
MyResourceHandler()
//offset_(0)
{}

  bool ProcessRequest(CefRefPtr&lt;CefRequest&gt; request,
                              CefRefPtr&lt;CefCallback&gt; callback) {

    CefRefPtr&lt;CefRequest&gt; cef   = CefRequest::Create();
    request = cef;
    CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS;
    request-&gt;SetReferrer("www.google.com",origin);
    return true;
    //cef-&gt;SetReferrer("www.google.com",origin);};
};

   void GetResponseHeaders(CefRefPtr&lt;CefResponse&gt; response,
                                  int64&amp; response_length,
                                  CefString&amp; redirectUrl) ;


   bool ReadResponse(void* data_out,
                            int bytes_to_read,
                            int&amp; bytes_read,
                            CefRefPtr&lt;CefCallback&gt; callback) ;

  bool CanGetCookie(const CefCookie&amp; cookie) { return true; }


   bool CanSetCookie(const CefCookie&amp; cookie) { return true; }


   void Cancel() ;

   void AddRef()const {} ;

bool Release() const { return true; }

 bool HasOneRef() const { return true; };

    //bool CefBase::HasOneRef();

    //void CefBase::AddRef() const;

 // bool ProcessRequest (CefRefPtr&lt;CefRequest&gt; request,
//CefRefPtr&lt;CefCallback&gt; callback){

//CefRefPtr&lt;CefRequest&gt; cef   = CefRequest::Create();
//cef = request;
//CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS;
//request-&gt;SetReferrer("www.google.com",origin);
//cef-&gt;SetReferrer("www.google.com",origin);

//}

//IMPLEMENT_REFCOUNTING(MyResourceHandler);
//IMPLEMENT_LOCKING(MyResourceHandler);
};

//void AddRef();

  ///
  // Called on the IO thread when a resource load is redirected. The |request|
  // parameter will contain the old URL and other request-related information.
  // The |new_url| parameter will contain the new URL and can be changed if
  // desired. The |request| object cannot be modified in this callback.
  ///
  /*--cef()--*/
  virtual void OnResourceRedirect(CefRefPtr&lt;CefBrowser&gt; browser,
                                  CefRefPtr&lt;CefFrame&gt; frame,
                                  CefRefPtr&lt;CefRequest&gt; request,
                                  CefString&amp; new_url) {}

  ///
  // Called on the IO thread when a resource response is received. To allow the
  // resource to load normally return false. To redirect or retry the resource
  // modify |request| (url, headers or post body) and return true. The
  // |response| object cannot be modified in this callback.
  ///
  /*--cef()--*/
  virtual bool OnResourceResponse(CefRefPtr&lt;CefBrowser&gt; browser,
                                  CefRefPtr&lt;CefFrame&gt; frame,
                                  CefRefPtr&lt;CefRequest&gt; request,
                                  CefRefPtr&lt;CefResponse&gt; response) {
    return false;
  }

  ///
  // Called on the IO thread to optionally filter resource response content.
  // |request| and |response| represent the request and response respectively
  // and cannot be modified in this callback.
  ///
  /*--cef()--*/
  virtual CefRefPtr&lt;CefResponseFilter&gt; GetResourceResponseFilter(
      CefRefPtr&lt;CefBrowser&gt; browser,
      CefRefPtr&lt;CefFrame&gt; frame,
      CefRefPtr&lt;CefRequest&gt; request,
      CefRefPtr&lt;CefResponse&gt; response) {
    return NULL;
  }

  ///
  // Called on the IO thread when a resource load has completed. |request| and
  // |response| represent the request and response respectively and cannot be
  // modified in this callback. |status| indicates the load completion status.
  // |received_content_length| is the number of response bytes actually read.
  ///
  /*--cef()--*/
  virtual void OnResourceLoadComplete(CefRefPtr&lt;CefBrowser&gt; browser,
                                      CefRefPtr&lt;CefFrame&gt; frame,
                                      CefRefPtr&lt;CefRequest&gt; request,
                                      CefRefPtr&lt;CefResponse&gt; response,
                                      URLRequestStatus status,
                                      int64 received_content_length) {}

  ///
  // Called on the IO thread when the browser needs credentials from the user.
  // |isProxy| indicates whether the host is a proxy server. |host| contains the
  // hostname and |port| contains the port number. |realm| is the realm of the
  // challenge and may be empty. |scheme| is the authentication scheme used,
  // such as "basic" or "digest", and will be empty if the source of the request
  // is an FTP server. Return true to continue the request and call
  // CefAuthCallback::Continue() either in this method or at a later time when
  // the authentication information is available. Return false to cancel the
  // request immediately.
  ///
  /*--cef(optional_param=realm,optional_param=scheme)--*/
  virtual bool GetAuthCredentials(CefRefPtr&lt;CefBrowser&gt; browser,
                                  CefRefPtr&lt;CefFrame&gt; frame,
                                  bool isProxy,
                                  const CefString&amp; host,
                                  int port,
                                  const CefString&amp; realm,
                                  const CefString&amp; scheme,
                                  CefRefPtr&lt;CefAuthCallback&gt; callback) {
    return false;
  }

  ///
  // Called on the IO thread when JavaScript requests a specific storage quota
  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the
  // origin of the page making the request. |new_size| is the requested quota
  // size in bytes. Return true to continue the request and call
  // CefRequestCallback::Continue() either in this method or at a later time to
  // grant or deny the request. Return false to cancel the request immediately.
  ///
  /*--cef()--*/
  virtual bool OnQuotaRequest(CefRefPtr&lt;CefBrowser&gt; browser,
                              const CefString&amp; origin_url,
                              int64 new_size,
                              CefRefPtr&lt;CefRequestCallback&gt; callback) {
    return false;
  }

  ///
  // Called on the UI thread to handle requests for URLs with an unknown
  // protocol component. Set |allow_os_execution| to true to attempt execution
  // via the registered OS protocol handler, if any.
  // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED
  // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
  ///
  /*--cef()--*/
  virtual void OnProtocolExecution(CefRefPtr&lt;CefBrowser&gt; browser,
                                   const CefString&amp; url,
                                   bool&amp; allow_os_execution) {}

  ///
  // Called on the UI thread to handle requests for URLs with an invalid
  // SSL certificate. Return true and call CefRequestCallback::Continue() either
  // in this method or at a later time to continue or cancel the request. Return
  // false to cancel the request immediately. If
  // CefSettings.ignore_certificate_errors is set all invalid certificates will
  // be accepted without calling this method.
  ///
  /*--cef()--*/
  virtual bool OnCertificateError(
      CefRefPtr&lt;CefBrowser&gt; browser,
      cef_errorcode_t cert_error,
      const CefString&amp; request_url,
      CefRefPtr&lt;CefSSLInfo&gt; ssl_info,
      CefRefPtr&lt;CefRequestCallback&gt; callback) {
    return false;
  }

  ///
  // Called on the browser process UI thread when a plugin has crashed.
  // |plugin_path| is the path of the plugin that crashed.
  ///
  /*--cef()--*/
  virtual void OnPluginCrashed(CefRefPtr&lt;CefBrowser&gt; browser,
                               const CefString&amp; plugin_path) {}

  ///
  // Called on the browser process UI thread when the render view associated
  // with |browser| is ready to receive/handle IPC messages in the render
  // process.
  ///
  /*--cef()--*/
  virtual void OnRenderViewReady(CefRefPtr&lt;CefBrowser&gt; browser) {}

  ///
  // Called on the browser process UI thread when the render process
  // terminates unexpectedly. |status| indicates how the process
  // terminated.
  ///
  /*--cef()--*/
  virtual void OnRenderProcessTerminated(CefRefPtr&lt;CefBrowser&gt; browser,
                                         TerminationStatus status) {}
};

#endif
</code></pre>

<p>The main function:</p>

<pre><code>#include "cefsimple/simple_app.h"

#include "include/cef_request.h"

#include &lt;X11/Xlib.h&gt;

#include "include/base/cef_logging.h"

namespace {

int XErrorHandlerImpl(Display *display, XErrorEvent *event) {
  LOG(WARNING)
        &lt;&lt; "X error received: "
        &lt;&lt; "type " &lt;&lt; event-&gt;type &lt;&lt; ", "
        &lt;&lt; "serial " &lt;&lt; event-&gt;serial &lt;&lt; ", "
        &lt;&lt; "error_code " &lt;&lt; static_cast&lt;int&gt;(event-&gt;error_code) &lt;&lt; ", "
        &lt;&lt; "request_code " &lt;&lt; static_cast&lt;int&gt;(event-&gt;request_code) &lt;&lt; ", "
        &lt;&lt; "minor_code " &lt;&lt; static_cast&lt;int&gt;(event-&gt;minor_code);
  return 0;
}

int XIOErrorHandlerImpl(Display *display) {
  return 0;
}

}  // namespace


// Entry point function for all processes.
int main(int argc, char* argv[]) {
  // Provide CEF with command-line arguments.
  CefMainArgs main_args(argc, argv);

 //cef_referrer_policy_t ReferrerPolicy;
//cef_referrer_policy_t =  "origin";




  // CEF applications have multiple sub-processes (render, plugin, GPU, etc)
  // that share the same executable. This function checks the command-line and,
  // if this is a sub-process, executes the appropriate logic.
  int exit_code = CefExecuteProcess(main_args, NULL, NULL);
  if (exit_code &gt;= 0) {
    // The sub-process has completed so return here.
    return exit_code;
  }

  // Install xlib error handlers so that the application won't be terminated
  // on non-fatal errors.
  XSetErrorHandler(XErrorHandlerImpl);
  XSetIOErrorHandler(XIOErrorHandlerImpl);

  // Specify CEF global settings here.
  CefSettings settings;


  // SimpleApp implements application-level callbacks for the browser process.
  // It will create the first browser instance in OnContextInitialized() after
  // CEF has initialized.
  CefRefPtr&lt;SimpleApp&gt; app(new SimpleApp);






  // Initialize CEF for the browser process.
  CefInitialize(main_args, settings, app.get(), NULL);


  // Run the CEF message loop. This will block until CefQuitMessageLoop() is
  // called.
  CefRunMessageLoop();


  // Shut down CEF.
  CefShutdown();

  return 0;
}
</code></pre>