CEF3中如何截获XMLHttpRequest(XHR)的笔记

最新推荐文章于 2023-04-26 23:24:36 发布

anlun

最新推荐文章于 2023-04-26 23:24:36 发布

阅读量2k

点赞数

分类专栏： ASP.NET C# 文章标签： c# xmlhttprequest

C# 同时被 2 个专栏收录

43 篇文章 2 订阅

订阅专栏

ASP.NET

17 篇文章 1 订阅

订阅专栏

标题：CEF3中如何截获XMLHttpRequest(HDR)请求和返回数据！

Title: How to intercept XMLHttpRequest in CEF3!

阅读对象：主要是给自己看的，免得以后忘记。

环境：[1]VS2013SP3 [2]cef_binary_3.1916.1804_windows32

第一次更新日期：2014-11-4

最近更新日期：2014-11-4

正文：

总共分为四步步骤:

第一步：

[cpp]view plaincopy 
   
 extern UINT WM_XMLHttpRequest;  
 CefRefPtr<CefResourceHandler> ClientHandler::GetResourceHandler(CefRefPtr<CefBrowser> browser,   
     CefRefPtr<CefFrame> frame, CefRefPtr<CefRequest> request)  
 {  
     //http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10794  
     if (request->GetResourceType() == RT_XHR)  
     {  
         //Second?  
         CefRefPtr<KagulaResourceHandler> resHandler = new KagulaResourceHandler();  
         resHandler->_browser = browser;  
         resHandler->_frame = frame;  
         resHandler->_clientHandler = this;  
   
         return  resHandler;  
     }  
     return NULL;  
 }  

第二步：

KagulaResourceHandler.h清单

[cpp]view plaincopy 
   
 #pragma once  
 #include <include/cef_app.h>  
 #include <include/cef_urlrequest.h>  
 class ClientHandler;  
 class KagulaUrlRequestClient;  
 class KagulaResourceHandler : public CefResourceHandler  
 {  
 public:  
     KagulaResourceHandler() :  
         _offset(0)  
     {}  
   
     virtual bool   ProcessRequest(CefRefPtr<CefRequest> request,  
         CefRefPtr<CefCallback> callback)  
         OVERRIDE;  
     virtual void   GetResponseHeaders(CefRefPtr<CefResponse> response,  
         int64& response_length,  
         CefString& redirectUrl) OVERRIDE;  
     virtual void   Cancel() OVERRIDE;  
   
     virtual bool   ReadResponse(void* data_out, int bytes_to_read,  
         int& bytes_read,  
         CefRefPtr<CefCallback> callback)  
         OVERRIDE;  
   
 public:  
     CefRefPtr<ClientHandler> _clientHandler;  
     CefRefPtr<CefBrowser> _browser;  
     CefRefPtr<CefFrame> _frame;  
   
     CefRefPtr<CefCallback> _responseHeadersReadyCallback;  
   
     CefRefPtr<KagulaUrlRequestClient> _webRequestClient;  
     CefRefPtr<CefURLRequest> _webRequest;  
   
     std::string _content;  
 private:  
     size_t _offset;  
   
     IMPLEMENT_REFCOUNTING(KagulaResourceHandler);  
     IMPLEMENT_LOCKING(KagulaResourceHandler);  
 };  

KagulaResourceHandler.cpp清单

[cpp]view plaincopy 
   
 #include <assert.h>  
   
 #include "KagulaResourceHandler.h"  
 #include "client_handler.h"  
 #include "KagulaUrlRequestClient.h"  
   
 bool KagulaResourceHandler::ProcessRequest(CefRefPtr<CefRequest> request,  
     CefRefPtr<CefCallback> callback)  
 {  
     //1. Start the request using WebRequest  
     //2. Return True to handle the request  
     //3. Once response headers are ready call  
     //   callback.Continue()  
     _responseHeadersReadyCallback = callback;  
   
     _webRequestClient = new KagulaUrlRequestClient(_frame);  
     _webRequestClient->_resourceHandler = this;  
     request->SetFlags(UR_FLAG_ALLOW_CACHED_CREDENTIALS | UR_FLAG_ALLOW_COOKIES);  
   
     //To skip cache :  
     //| request.SetFlags(cefpython.Request.Flags["SkipCache"])  
     //Must keep a strong reference to the WebRequest() object.  
     _webRequest = CefURLRequest::Create(request, _webRequestClient.get());  
   
     return true;  
 }  
   
 void KagulaResourceHandler::GetResponseHeaders(CefRefPtr<CefResponse> response,  
     int64& response_length, CefString& redirectUrl)  
 {  
     assert(CefCurrentlyOn(TID_IO));  
     //if (this->mimeType)  
     //{  
     //  response->SetMimeType(CefString(this->mimeType));  
     //  response->SetStatus(200);  
     //}  
     //else  
     //{  
     //  response->SetStatus(500);  
     //}  
     CefRefPtr<CefResponse> webResponse = _webRequestClient->_response;  
   
     if (webResponse!=nullptr)  
     {  
         CefResponse::HeaderMap headerMap;  
         webResponse->GetHeaderMap(headerMap);  
         response->SetHeaderMap(headerMap);  
         response->SetStatus(webResponse->GetStatus());  
         response->SetStatusText(webResponse->GetStatusText());  
         CefString cefstr = webResponse->GetMimeType();  
         if (!cefstr.empty())  
         {  
             response->SetMimeType(webResponse->GetMimeType());  
         }  
     }  
   
     response_length = _content.size();  
     _offset = 0;  
 }  
   
 void KagulaResourceHandler::Cancel()  
 {  
 }  
   
 bool KagulaResourceHandler::ReadResponse(void* data_out, int bytes_to_read,  
     int& bytes_read, CefRefPtr<CefCallback> callback)  
 {  
     //here fill what response data will be return!  
     size_t size = _content.size();  
   
     if (_offset < size) {  
           
         int transfer_size = min(bytes_to_read, static_cast<int>(size - _offset));  
   
         memcpy(data_out, _content.c_str() + _offset, transfer_size);  
         _offset += transfer_size;  
   
         bytes_read = transfer_size;//output  
   
         char *pDataOut = (char*)data_out;  
         return true;  
     }  
     return false;  
 }  

KagulaUrlRequestClient.h清单

[cpp]view plaincopy 
   
 #pragma once  
 #include <include/cef_app.h>  
 #include <include/cef_urlrequest.h>  
   
 #include "KagulaResourceHandler.h"  
   
 #include <string>  
 #include <map>  
   
 class KagulaUrlRequestClient : public CefURLRequestClient  
 {  
 public:  
     KagulaUrlRequestClient(CefRefPtr<CefFrame> _frame):_dataLength(0)   
     {}  
   
     // CefURLRequestClient methods  
     virtual void OnRequestComplete(CefRefPtr<CefURLRequest> request) OVERRIDE;  
     virtual void OnUploadProgress(CefRefPtr<CefURLRequest> request, uint64 current, uint64 total) OVERRIDE;  
     virtual void OnDownloadData(CefRefPtr<CefURLRequest> request, const void* data, size_t data_length) OVERRIDE;  
     virtual void OnDownloadProgress(CefRefPtr<CefURLRequest> request, uint64 current, uint64 total) OVERRIDE;  
     virtual bool GetAuthCredentials(bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr<CefAuthCallback> callback) OVERRIDE;  
 public:  
     CefRefPtr<CefResponse> _response;  
     CefRefPtr<KagulaResourceHandler> _resourceHandler;  
   
     std::string _data;  
     size_t _dataLength;  
 private:  
     IMPLEMENT_REFCOUNTING(KagulaUrlRequestClient);  
 };  

KagulaUrlRequestClient.cpp清单

[cpp]view plaincopy 
   
 #include "KagulaUrlRequestClient.h"  
 #include "client_handler.h"  
   
 void KagulaUrlRequestClient::OnRequestComplete(CefRefPtr<CefURLRequest> request)  
 {  
     std::string statusText = "Unknown";  
     std::map<int,std::string> mqpReqStatus;  
     mqpReqStatus[0]="Unknown";  
     mqpReqStatus[1]="Success";  
     mqpReqStatus[2]="Pending";  
     mqpReqStatus[3]="Canceled";  
     mqpReqStatus[4]="Failed";  
   
     if (mqpReqStatus.find(request->GetRequestStatus()) != mqpReqStatus.end())  
         statusText = mqpReqStatus[request->GetRequestStatus()];  
   
     _response = request->GetResponse();  
   
         _data = _resourceHandler->_clientHandler->_OnResourceResponse(  
             _resourceHandler->_browser,  
             _resourceHandler->_frame,  
             request->GetRequest(),  
             request->GetRequestStatus(),  
             request->GetRequestError(),  
             request->GetResponse(),  
             _data);  
   
     _dataLength = _data.length();  
   
     //ResourceHandler.GetResponseHeaders() will get called  
     //after _responseHeadersReadyCallback.Continue() is called.  
     _resourceHandler->_content = _data;  
     _resourceHandler->_responseHeadersReadyCallback->Continue();  
 }  
   
 void KagulaUrlRequestClient::OnUploadProgress(CefRefPtr<CefURLRequest> request, uint64 current, uint64 total)  
 {  
 }  
   
 void KagulaUrlRequestClient::OnDownloadData(CefRefPtr<CefURLRequest> request, const void* data, size_t data_length)  
 {  
     char* buf = new char[data_length + 1];  
     if (buf!=nullptr)  
     {  
         memset(buf, 0, data_length + 1);  
         memcpy(buf, data, data_length);  
         _data += buf;  
         delete buf;  
     }  
 }  
   
 void KagulaUrlRequestClient::OnDownloadProgress(CefRefPtr<CefURLRequest> request, uint64 current, uint64 total)  
 {  
 }  
   
 bool KagulaUrlRequestClient::GetAuthCredentials(bool isProxy, const CefString& host, int port, const CefString& realm, const CefString& scheme, CefRefPtr<CefAuthCallback> callback)  
 {  
     return true;  
 }  

第三步：

[cpp]view plaincopy 
   
 std::string ClientHandler::_OnResourceResponse(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefRequest> request,   
     CefURLRequest::Status status, CefURLRequest::ErrorCode errorCode, CefRefPtr<CefResponse> response, std::string data)  
 {  
     std::string _data = data;  
     std::string strPostData;  
   
     std::wstring wsR = L"url=>";  
     wsR.append(frame->GetURL().ToWString());  
     wsR.append(L"post data=>");  
     {  
         CefRefPtr<CefPostData> postData = request->GetPostData();  
   
         if (postData != NULL) {  
             CefPostData::ElementVector elements;  
             postData->GetElements(elements);  
   
             if (elements.size() > 0) {  
   
                 std::wstring queryString;  
   
                 // it looks like the whole query string is in this first post data element?  
                 CefRefPtr<CefPostDataElement> query = elements[0];  
   
                 if (query->GetType() == PDE_TYPE_BYTES || query->GetType() == PDE_TYPE_FILE) {  
                     const unsigned int buffSize = query->GetBytesCount() >= 1024 ? 1024 : query->GetBytesCount() + 1;  
                     char *buff = new char[buffSize];  
                     if (buff!=nullptr)  
                     {  
                         //Get Post Data  
                         memset(buff, 0, buffSize);  
                           
                         query->GetBytes(query->GetBytesCount() >= buffSize ? buffSize-1 : query->GetBytesCount(), buff);  
                         strPostData = buff;  
                           
                         wsR.append(kagula::s2ws_FromUTF8(strPostData));  
                         delete[] buff;  
                     }  
                 }  
             }  
         }  
     }  
     wsR.append(L"content=>");  
     wsR.append(kagula::s2ws_FromUTF8(data));  
     LOG_TRACE(wsR.c_str());  
   
     //  
     CefString url = frame->GetURL();  
     //send to my main window!  
     std::vector<std::string> vecStr;  
     vecStr.push_back(url.ToString());  
     vecStr.push_back(strPostData);  
     vecStr.push_back(data);  
     CIPCData::SetVecStr(vecStr);  
     HWND hwnd = (HWND)(CIPCData::GetMainHWND());  
     SendMessage(hwnd, WM_XMLHttpRequest, NULL, NULL);  
   
     return _data;  
 }  

第四步：

[cpp]view plaincopy 
   
 LRESULT Ccat8637_BrandDlg::OnXMLHttpRequest(WPARAM wParam, LPARAM lParam)  
 {  
     std::vector<std::string> vecS;  
     CIPCData::GetVecStr(vecS);  
     if (vecS.size() == 3)  
     {  
 #ifdef _DEBUG  
         std::wstring strMsg = L"OnXMLHttpRequest=>";   
         strMsg.append(kagula::s2ws_FromUTF8(vecS[2]));  
         LOG_TRACE(strMsg);  
 #endif  
     }  
   
     return S_OK;  
 }  

anlun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
CEF3中如何截获XMLHttpRequest(XHR)的笔记

标题：CEF3中如何截获XMLHttpRequest(HDR)请求和返回数据！Title: How to intercept XMLHttpRequest in CEF3!阅读对象：主要是给自己看的，免得以后忘记。环境：[1]VS2013SP3 [2]cef_binary_3.1916.1804_windows32第一次更新日期：2014-11-4最近更
复制链接

扫一扫

专栏目录