1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102


content / browser / webid / test / delegated_idp_network_request_manager.cc [blame]

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/webid/test/delegated_idp_network_request_manager.h"

namespace content {

DelegatedIdpNetworkRequestManager::DelegatedIdpNetworkRequestManager(
    IdpNetworkRequestManager* delegate)
    : delegate_(delegate) {
  DCHECK(delegate_);
}

DelegatedIdpNetworkRequestManager::~DelegatedIdpNetworkRequestManager() =
    default;

void DelegatedIdpNetworkRequestManager::FetchWellKnown(
    const GURL& provider,
    FetchWellKnownCallback callback) {
  delegate_->FetchWellKnown(provider, std::move(callback));
}

void DelegatedIdpNetworkRequestManager::FetchConfig(
    const GURL& provider,
    blink::mojom::RpMode rp_mode,
    int idp_brand_icon_ideal_size,
    int idp_brand_icon_minimum_size,
    FetchConfigCallback callback) {
  delegate_->FetchConfig(provider, rp_mode, idp_brand_icon_ideal_size,
                         idp_brand_icon_minimum_size, std::move(callback));
}

void DelegatedIdpNetworkRequestManager::FetchClientMetadata(
    const GURL& endpoint,
    const std::string& client_id,
    int rp_brand_icon_ideal_size,
    int rp_brand_icon_minimum_size,
    FetchClientMetadataCallback callback) {
  delegate_->FetchClientMetadata(endpoint, client_id, rp_brand_icon_ideal_size,
                                 rp_brand_icon_minimum_size,
                                 std::move(callback));
}

void DelegatedIdpNetworkRequestManager::SendAccountsRequest(
    const GURL& accounts_url,
    const std::string& client_id,
    AccountsRequestCallback callback) {
  delegate_->SendAccountsRequest(accounts_url, client_id, std::move(callback));
}

void DelegatedIdpNetworkRequestManager::SendTokenRequest(
    const GURL& token_url,
    const std::string& account,
    const std::string& url_encoded_post_data,
    TokenRequestCallback callback,
    ContinueOnCallback continue_on,
    RecordErrorMetricsCallback record_error_metrics_callback) {
  delegate_->SendTokenRequest(token_url, account, url_encoded_post_data,
                              std::move(callback), std::move(continue_on),
                              std::move(record_error_metrics_callback));
}

void DelegatedIdpNetworkRequestManager::SendSuccessfulTokenRequestMetrics(
    const GURL& metrics_endpoint_url,
    base::TimeDelta api_call_to_show_dialog_time,
    base::TimeDelta show_dialog_to_continue_clicked_time,
    base::TimeDelta account_selected_to_token_response_time,
    base::TimeDelta api_call_to_token_response_time) {
  delegate_->SendSuccessfulTokenRequestMetrics(
      metrics_endpoint_url, api_call_to_show_dialog_time,
      show_dialog_to_continue_clicked_time,
      account_selected_to_token_response_time, api_call_to_token_response_time);
}

void DelegatedIdpNetworkRequestManager::SendFailedTokenRequestMetrics(
    const GURL& metrics_endpoint_url,
    MetricsEndpointErrorCode error_code) {
  delegate_->SendFailedTokenRequestMetrics(metrics_endpoint_url, error_code);
}

void DelegatedIdpNetworkRequestManager::SendLogout(const GURL& logout_url,
                                                   LogoutCallback callback) {
  delegate_->SendLogout(logout_url, std::move(callback));
}

void DelegatedIdpNetworkRequestManager::SendDisconnectRequest(
    const GURL& disconnect_url,
    const std::string& account_hint,
    const std::string& client_id,
    DisconnectCallback callback) {
  delegate_->SendDisconnectRequest(disconnect_url, account_hint, client_id,
                                   std::move(callback));
}

void DelegatedIdpNetworkRequestManager::DownloadAndDecodeImage(
    const GURL& url,
    ImageCallback callback) {
  delegate_->DownloadAndDecodeImage(url, std::move(callback));
}

}  // namespace content