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
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127
  128


content / public / test / browsing_topics_test_util.cc [blame]

// Copyright 2021 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/public/test/browsing_topics_test_util.h"

#include "base/task/single_thread_task_runner.h"
#include "base/test/bind.h"
#include "components/browsing_topics/common/common_types.h"
#include "content/browser/browsing_topics/browsing_topics_site_data_manager_impl.h"

namespace content {

std::vector<browsing_topics::ApiUsageContext> GetBrowsingTopicsApiUsage(
    content::BrowsingTopicsSiteDataManager* topics_site_data_manager) {
  browsing_topics::ApiUsageContextQueryResult query_result;

  base::RunLoop run_loop;
  topics_site_data_manager->GetBrowsingTopicsApiUsage(
      base::Time(), base::Time::Now() + base::Days(1),
      base::BindLambdaForTesting(
          [&](browsing_topics::ApiUsageContextQueryResult result) {
            query_result = std::move(result);
            run_loop.Quit();
          }));

  run_loop.Run();

  DCHECK(query_result.success);

  std::vector<browsing_topics::ApiUsageContext> api_usage_contexts =
      std::move(query_result.api_usage_contexts);

  std::sort(api_usage_contexts.begin(), api_usage_contexts.end(),
            [](auto& left, auto& right) {
              return left.hashed_context_domain != right.hashed_context_domain
                         ? left.hashed_context_domain <
                               right.hashed_context_domain
                         : (left.hashed_main_frame_host !=
                                    right.hashed_main_frame_host
                                ? left.hashed_main_frame_host <
                                      right.hashed_main_frame_host
                                : left.time < right.time);
            });

  return api_usage_contexts;
}

std::map<browsing_topics::HashedDomain, std::string>
GetContextDomainsFromHashedContextDomains(
    content::BrowsingTopicsSiteDataManager* topics_site_data_manager,
    std::set<browsing_topics::HashedDomain> hashed_context_domains) {
  base::RunLoop run_loop;

  std::map<browsing_topics::HashedDomain, std::string> query_result;
  topics_site_data_manager->GetContextDomainsFromHashedContextDomains(
      hashed_context_domains,
      base::BindLambdaForTesting(
          [&](std::map<browsing_topics::HashedDomain, std::string> result) {
            query_result = result;
            run_loop.Quit();
          }));

  run_loop.Run();
  return query_result;
}

TesterBrowsingTopicsSiteDataManager::TesterBrowsingTopicsSiteDataManager(
    const base::FilePath& user_data_directory)
    : manager_impl_(
          new BrowsingTopicsSiteDataManagerImpl(user_data_directory)) {}

void TesterBrowsingTopicsSiteDataManager::ExpireDataBefore(base::Time time) {
  manager_impl_->ExpireDataBefore(time);
}

void TesterBrowsingTopicsSiteDataManager::ClearContextDomain(
    const browsing_topics::HashedDomain& hashed_context_domain) {
  manager_impl_->ClearContextDomain(hashed_context_domain);
}

TesterBrowsingTopicsSiteDataManager::~TesterBrowsingTopicsSiteDataManager() =
    default;

void TesterBrowsingTopicsSiteDataManager::OnBrowsingTopicsApiUsed(
    const browsing_topics::HashedHost& hashed_top_host,
    const browsing_topics::HashedDomain& hashed_context_domain,
    const std::string& context_domain,
    base::Time time) {
  manager_impl_->OnBrowsingTopicsApiUsed(hashed_top_host, hashed_context_domain,
                                         context_domain, time);
}

void TesterBrowsingTopicsSiteDataManager::GetBrowsingTopicsApiUsage(
    base::Time begin_time,
    base::Time end_time,
    GetBrowsingTopicsApiUsageCallback callback) {
  auto run_callback_after_delay = base::BindLambdaForTesting(
      [callback = std::move(callback),
       this](browsing_topics::ApiUsageContextQueryResult result) mutable {
        base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
            FROM_HERE,
            base::BindLambdaForTesting([callback = std::move(callback),
                                        result = std::move(result)]() mutable {
              std::move(callback).Run(std::move(result));
            }),
            query_result_delay_);
      });

  if (!query_failure_override_) {
    manager_impl_->GetBrowsingTopicsApiUsage(
        begin_time, end_time, std::move(run_callback_after_delay));
    return;
  }

  std::move(run_callback_after_delay)
      .Run(browsing_topics::ApiUsageContextQueryResult());
}

void TesterBrowsingTopicsSiteDataManager::
    GetContextDomainsFromHashedContextDomains(
        const std::set<browsing_topics::HashedDomain>& hashed_context_domains,
        GetContextDomainsFromHashedContextDomainsCallback callback) {
  manager_impl_->GetContextDomainsFromHashedContextDomains(
      hashed_context_domains, std::move(callback));
}

}  // namespace content