はCefRequesthandlerクラスの仮想関数C++

Question

関数（cef_request_handler.h）を実装します。私はSimplehandlerクラスからCefRequestHandlerクラスを拡張しませんでした

#include "include/cef_request_handler.h" 

：

virtual ReturnValue OnBeforeResourceLoad(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback) OVERRIDE; 

はSimpleHandlerクラスファイルに以下を追加しました。私はそれが必要とは思わない。下図のように私のSimplehandler.ccファイルで

、私は機能を実装：

error: no ‘CefRequestHandler::ReturnValue SimpleHandler::OnBeforeResourceLoad(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame>, CefRefPtr<CefRequest>, CefRefPtr<CefRequestCallback>)’ member function declared in class ‘SimpleHandler’ 
     CefRefPtr<CefRequestCallback> callback){ 
              ^

CefRequestHandler::ReturnValueがCefRequestHandlerで次のステートメントに由来している：

CefRequestHandler::ReturnValue SimpleHandler::OnBeforeResourceLoad(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback){ 

CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS; 
request->SetReferrer("www.google.com",origin); 


    return RV_CONTINUE; 

} 

を私は次のエラーが取得クラス：

typedef cef_return_value_t ReturnValue;

コンパイラには何がありますか？no member function declared in class ‘SimpleHandler’とは何ですか？

simple_handler.h/SimpleHandlerクラス

// 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_HANDLER_H_ 
#define CEF_TESTS_CEFSIMPLE_SIMPLE_HANDLER_H_ 

#include "include/cef_client.h" 

#include "include/cef_request_handler.h" 




#include <list> 

class SimpleHandler : public CefClient, 
         public CefDisplayHandler, 
         public CefLifeSpanHandler, 
         public CefLoadHandler { 
public: 
    explicit SimpleHandler(bool use_views); 
    ~SimpleHandler(); 

    // Provide access to the single global instance of this object. 
    static SimpleHandler* GetInstance(); 

    // CefClient methods: 
    virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE { 
    return this; 
    } 
    virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE { 
    return this; 
    } 
    virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE { 
    return this; 
    } 

    // CefDisplayHandler methods: 
    virtual void OnTitleChange(CefRefPtr<CefBrowser> browser, 
          const CefString& title) OVERRIDE; 

    // CefLifeSpanHandler methods: 
    virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE; 
    virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE; 
    virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE; 

    // CefLoadHandler methods: 
    virtual void OnLoadError(CefRefPtr<CefBrowser> browser, 
          CefRefPtr<CefFrame> frame, 
          ErrorCode errorCode, 
          const CefString& errorText, 
          const CefString& failedUrl) OVERRIDE; 

virtual ReturnValue OnBeforeResourceLoad(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback) OVERRIDE; 

//{ return false; } 



    // Request that all existing browser windows close. 
    void CloseAllBrowsers(bool force_close); 

    bool IsClosing() const { return is_closing_; } 

private: 
    // Platform-specific implementation. 
    void PlatformTitleChange(CefRefPtr<CefBrowser> browser, 
          const CefString& title); 

    // True if the application is using the Views framework. 
    const bool use_views_; 

    // List of existing browser windows. Only accessed on the CEF UI thread. 
    typedef std::list<CefRefPtr<CefBrowser> > BrowserList; 
    BrowserList browser_list_; 

    bool is_closing_; 

    // Include the default reference counting implementation. 
    IMPLEMENT_REFCOUNTING(SimpleHandler); 
}; 

#endif // CEF_TESTS_CEFSIMPLE_SIMPLE_HANDLER_H_ 

simple_handler.cc

Cefrequesthandlerクラスcef_request_handler.h

// 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. 

#include "cefsimple/simple_handler.h" 

#include <sstream> 
#include <string> 

#include "include/base/cef_bind.h" 
#include "include/cef_app.h" 
#include "include/views/cef_browser_view.h" 
#include "include/views/cef_window.h" 
#include "include/wrapper/cef_closure_task.h" 
#include "include/wrapper/cef_helpers.h" 
#include "include/cef_request_handler.h" 

namespace { 

SimpleHandler* g_instance = NULL; 

} // namespace 

SimpleHandler::SimpleHandler(bool use_views) 
    : use_views_(use_views), 
     is_closing_(false) { 
    DCHECK(!g_instance); 
    g_instance = this; 
} 

SimpleHandler::~SimpleHandler() { 
    g_instance = NULL; 
} 

// static 
SimpleHandler* SimpleHandler::GetInstance() { 
    return g_instance; 
} 

void SimpleHandler::OnTitleChange(CefRefPtr<CefBrowser> browser, 
            const CefString& title) { 
    CEF_REQUIRE_UI_THREAD(); 

    if (use_views_) { 
    // Set the title of the window using the Views framework. 
    CefRefPtr<CefBrowserView> browser_view = 
     CefBrowserView::GetForBrowser(browser); 
    if (browser_view) { 
     CefRefPtr<CefWindow> window = browser_view->GetWindow(); 
     if (window) 
     window->SetTitle(title); 
    } 
    } else { 
    // Set the title of the window using platform APIs. 
    PlatformTitleChange(browser, title); 
    } 
} 

void SimpleHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) { 
    CEF_REQUIRE_UI_THREAD(); 

    // Add to the list of existing browsers. 
    browser_list_.push_back(browser); 
} 

CefRequestHandler::ReturnValue SimpleHandler::OnBeforeResourceLoad(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback){ 

CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS; 
request->SetReferrer("www.google.com",origin); 


    return RV_CONTINUE; 

} 

bool SimpleHandler::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 (browser_list_.size() == 1) { 
    // Set a flag to indicate that the window close should be allowed. 
    is_closing_ = true; 
    } 

    // Allow the close. For windowed browsers this will result in the OS close 
    // event being sent. 
    return false; 
} 

void SimpleHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) { 
    CEF_REQUIRE_UI_THREAD(); 

    // Remove from the list of existing browsers. 
    BrowserList::iterator bit = browser_list_.begin(); 
    for (; bit != browser_list_.end(); ++bit) { 
    if ((*bit)->IsSame(browser)) { 
     browser_list_.erase(bit); 
     break; 
    } 
    } 

    if (browser_list_.empty()) { 
    // All browser windows have closed. Quit the application message loop. 
    CefQuitMessageLoop(); 
    } 
} 

void SimpleHandler::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; 

    // 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 SimpleHandler::CloseAllBrowsers(bool force_close) { 
    if (!CefCurrentlyOn(TID_UI)) { 
    // Execute on the UI thread. 
    CefPostTask(TID_UI, 
     base::Bind(&SimpleHandler::CloseAllBrowsers, this, force_close)); 
    return; 
    } 

    if (browser_list_.empty()) 
    return; 

    BrowserList::const_iterator it = browser_list_.begin(); 
    for (; it != browser_list_.end(); ++it) 
    (*it)->GetHost()->CloseBrowser(force_close); 
} 

---

// 
// The contents of this file must follow a specific format in order to 
// support the CEF translator tool. See the translator.README.txt file in the 
// tools directory for more information. 
// 

#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<CefBrowser> browser, 
           CefRefPtr<CefFrame> frame, 
           CefRefPtr<CefRequest> 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<CefBrowser> browser, 
           CefRefPtr<CefFrame> frame, 
           const CefString& 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<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback) { 

//CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS; 
// request->SetReferrer("www.google.com",origin); 
    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<CefResourceHandler> GetResourceHandler(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request) { 

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

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

    bool ProcessRequest(CefRefPtr<CefRequest> request, 
           CefRefPtr<CefCallback> callback) { 

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

    void GetResponseHeaders(CefRefPtr<CefResponse> response, 
            int64& response_length, 
            CefString& redirectUrl) ; 


    bool ReadResponse(void* data_out, 
          int bytes_to_read, 
          int& bytes_read, 
          CefRefPtr<CefCallback> callback) ; 

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


    bool CanSetCookie(const CefCookie& 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<CefRequest> request, 
//CefRefPtr<CefCallback> callback){ 

//CefRefPtr<CefRequest> cef = CefRequest::Create(); 
//cef = request; 
//CefRequest::ReferrerPolicy origin = REFERRER_POLICY_ALWAYS; 
//request->SetReferrer("www.google.com",origin); 
//cef->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<CefBrowser> browser, 
            CefRefPtr<CefFrame> frame, 
            CefRefPtr<CefRequest> request, 
            CefString& 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<CefBrowser> browser, 
            CefRefPtr<CefFrame> frame, 
            CefRefPtr<CefRequest> request, 
            CefRefPtr<CefResponse> 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<CefResponseFilter> GetResourceResponseFilter(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefResponse> 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<CefBrowser> browser, 
             CefRefPtr<CefFrame> frame, 
             CefRefPtr<CefRequest> request, 
             CefRefPtr<CefResponse> 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<CefBrowser> browser, 
            CefRefPtr<CefFrame> frame, 
            bool isProxy, 
            const CefString& host, 
            int port, 
            const CefString& realm, 
            const CefString& scheme, 
            CefRefPtr<CefAuthCallback> 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<CefBrowser> browser, 
           const CefString& origin_url, 
           int64 new_size, 
           CefRefPtr<CefRequestCallback> 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<CefBrowser> browser, 
            const CefString& url, 
            bool& 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<CefBrowser> browser, 
     cef_errorcode_t cert_error, 
     const CefString& request_url, 
     CefRefPtr<CefSSLInfo> ssl_info, 
     CefRefPtr<CefRequestCallback> 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<CefBrowser> browser, 
           const CefString& 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<CefBrowser> 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<CefBrowser> browser, 
             TerminationStatus status) {} 
}; 

#endif // CEF_INCLUDE_CEF_REQUEST_HANDLER_H_ 

Answer 1

SimpleHandlerはCefReq由来しませんuestHandler。ただし、SimpleHandlerの戻り値はCefRequestHandler修飾子なしで使用されています。ここで、関数の実装では、ReturnValueがCrefRequestHandler修飾子とともに使用されています。 - CrefRequestHandler :: ReturnValue SimpleHandler :: OnBeforeResourceLoad。

これは、SimpleHandlerの基本クラスの1つがReturnValue（CrefRequestHandler宣言とは異なる）も宣言しているため、定義では基本クラスの値を使用し、CefRequestHandlerの実装では、 。

以下のように定義を変更してください。

virtual CefRequestHandler::ReturnValue OnBeforeResourceLoad(
     CefRefPtr<CefBrowser> browser, 
     CefRefPtr<CefFrame> frame, 
     CefRefPtr<CefRequest> request, 
     CefRefPtr<CefRequestCallback> callback) OVERRIDE;