network_delegates.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_NETWORK_DELEGATES_HPP
#define MOLYBDEN_NETWORK_DELEGATES_HPP
 
#include <memory>
#include <vector>
 
#include "molybden/base/delegate.hpp"
#include "molybden/base/delegate_action.hpp"
#include "molybden/cookie/cookie.hpp"
#include "molybden/network/http_header.hpp"
#include "molybden/network/url_request.hpp"
 
namespace molybden {
 
class Network;
class UploadData;
class UrlRequestJob;
class UrlRequestJobFactory;
 
struct BeforeSendUploadDataArgs {
  std::shared_ptr<Network> network;
 
  UrlRequest url_request;
 
  std::shared_ptr<UploadData> upload_data;
 
  std::vector<HttpHeader> http_headers;
};
 
class BeforeSendUploadDataAction : public Action {
 public:
  explicit BeforeSendUploadDataAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void override(const std::shared_ptr<UploadData>& upload_data);
 
  void proceed();
};
 
struct CanSetCookieArgs {
  std::shared_ptr<Network> network;
 
  std::string url;
 
  Cookie cookie;
};
 
class CanSetCookieAction : public Action {
 public:
  explicit CanSetCookieAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void can();
 
  void cannot();
};
 
struct CanGetCookiesArgs {
  std::shared_ptr<Network> network;
 
  std::string url;
 
  std::vector<Cookie> cookies;
};
 
class CanGetCookiesAction : public Action {
 public:
  explicit CanGetCookiesAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void can();
 
  void cannot();
};
 
struct CanAccessFileArgs {
  std::shared_ptr<Network> network;
 
  std::string absolute_file_path;
};
 
class CanAccessFileAction : public Action {
 public:
  explicit CanAccessFileAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void can();
 
  void cannot();
};
 
struct ReceiveHeadersArgs {
  std::shared_ptr<Network> network;
 
  UrlRequest request;
 
  std::vector<HttpHeader> http_headers;
 
  std::string mime_type;
 
  std::string charset;
 
  std::string ip_address;
 
  std::string status_line;
 
  std::string status_text;
 
  int64_t content_length;
 
  uint16_t response_code;
};
 
class ReceiveHeadersAction : public Action {
 public:
  explicit ReceiveHeadersAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void override(const std::vector<HttpHeader>& headers);
 
  void proceed();
};
 
struct BeforeStartTransactionArgs {
  std::shared_ptr<Network> network;
 
  UrlRequest request;
 
  std::vector<HttpHeader> http_headers;
};
 
class BeforeStartTransactionAction : public Action {
 public:
  explicit BeforeStartTransactionAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void override(const std::vector<HttpHeader>& headers);
 
  void proceed();
};
 
struct BeforeUrlRequestArgs {
  std::shared_ptr<Network> network;
 
  UrlRequest request;
};
 
class BeforeUrlRequestAction : public Action {
 public:
  explicit BeforeUrlRequestAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void redirect(const std::string& url);
 
  void cancel();
 
  void proceed();
};
 
struct InterceptUrlRequestArgs {
  std::shared_ptr<Network> network;
 
  UrlRequest request;
 
  std::shared_ptr<UploadData> upload_data;
 
  std::vector<HttpHeader> http_headers;
 
  std::unique_ptr<UrlRequestJobFactory> job_factory;
};
 
class InterceptUrlRequestAction : public Action {
 public:
  explicit InterceptUrlRequestAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void intercept(std::shared_ptr<UrlRequestJob> url_request_job);
};
 
class NetworkDelegates {
 public:
  Delegate<BeforeSendUploadDataArgs, BeforeSendUploadDataAction>
      onBeforeSendUploadData;
 
  Delegate<CanSetCookieArgs, CanSetCookieAction> onCanSetCookie;
 
  Delegate<CanGetCookiesArgs, CanGetCookiesAction> onCanGetCookies;
 
  Delegate<CanAccessFileArgs, CanAccessFileAction> onCanAccessFile;
 
  Delegate<ReceiveHeadersArgs, ReceiveHeadersAction> onReceiveHeaders;
 
  Delegate<BeforeStartTransactionArgs, BeforeStartTransactionAction>
      onBeforeStartTransaction;
 
  Delegate<BeforeUrlRequestArgs, BeforeUrlRequestAction> onBeforeUrlRequest;
 
  Delegate<InterceptUrlRequestArgs, InterceptUrlRequestAction>
      onInterceptUrlRequest;
};
 
}  // namespace molybden
 
#endif  // MOLYBDEN_NETWORK_DELEGATES_HPP