chrome/browser/download/notification/multi_profile_download_notifier_unittest.cc

// 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 "chrome/browser/download/notification/multi_profile_download_notifier.h"

#include <memory>

#include "base/memory/raw_ptr.h"
#include "chrome/test/base/browser_with_test_window_test.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "components/download/content/public/all_download_item_notifier.h"
#include "components/download/public/common/mock_download_item.h"
#include "content/public/test/fake_download_item.h"
#include "content/public/test/mock_download_manager.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using ::testing::_;
using ::testing::AnyNumber;

namespace {

class MockNotifierClient : public MultiProfileDownloadNotifier::Client {
 public:
  MockNotifierClient() = default;
  ~MockNotifierClient() override = default;
  MockNotifierClient(const MockNotifierClient&) = delete;
  MockNotifierClient& operator=(const MockNotifierClient&) = delete;

  MOCK_METHOD(void,
              OnManagerInitialized,
              (content::DownloadManager * manager),
              (override));
  MOCK_METHOD(void,
              OnManagerGoingDown,
              (content::DownloadManager * manager),
              (override));
  MOCK_METHOD(void,
              OnDownloadCreated,
              (content::DownloadManager * manager,
               download::DownloadItem* item),
              (override));
  MOCK_METHOD(void,
              OnDownloadUpdated,
              (content::DownloadManager * manager,
               download::DownloadItem* item),
              (override));
  MOCK_METHOD(void,
              OnDownloadDestroyed,
              (content::DownloadManager * manager,
               download::DownloadItem* item),
              (override));
  MOCK_METHOD(bool, ShouldObserveProfile, (Profile * profile), (override));
};

// A mock `content::DownloadManager` which can notify observers of events.
class MockDownloadManager : public content::MockDownloadManager {
 public:
  // content::MockDownloadManager:
  void AddObserver(Observer* observer) override {
    observers_.AddObserver(observer);
  }

  void RemoveObserver(Observer* observer) override {
    observers_.RemoveObserver(observer);
  }

  void Shutdown() override {
    for (auto& observer : observers_)
      observer.ManagerGoingDown(this);
  }

 private:
  base::ObserverList<content::DownloadManager::Observer>::Unchecked observers_;
};

}  // namespace

class MultiProfileDownloadNotifierTest : public BrowserWithTestWindowTest {
 public:
  // BrowserWithTestWindowTest:
  void SetUp() override {
    notifier_ = std::make_unique<MultiProfileDownloadNotifier>(
        &client(), RequireManagerInitialization());
    BrowserWithTestWindowTest::SetUp();
  }

  TestingProfile* CreateProfile(const std::string& profile_name) override {
    auto* profile = BrowserWithTestWindowTest::CreateProfile(profile_name);
    SetUpDownloadManager(profile);
    return profile;
  }

  virtual bool ShouldInitializeManager() { return true; }

  virtual bool RequireManagerInitialization() { return true; }

  MockNotifierClient& client() { return client_; }

  MockDownloadManager* manager() { return manager_; }

  download::MockDownloadItem* item() { return &item_; }

  MultiProfileDownloadNotifier* notifier() { return notifier_.get(); }

  download::AllDownloadItemNotifier::Observer*
  notifier_as_all_download_item_notifier_observer() const {
    return notifier_.get();
  }

 private:
  // Creates a `MockDownloadManager` for `profile` to use.
  void SetUpDownloadManager(Profile* profile) {
    auto manager = std::make_unique<testing::NiceMock<MockDownloadManager>>();
    ON_CALL(*manager, IsManagerInitialized())
        .WillByDefault(testing::Return(ShouldInitializeManager()));
    manager_ = manager.get();
    profile->SetDownloadManagerForTesting(std::move(manager));
  }

  testing::NiceMock<MockNotifierClient> client_;
  raw_ptr<testing::NiceMock<MockDownloadManager>, DanglingUntriaged> manager_;
  testing::NiceMock<download::MockDownloadItem> item_;
  std::unique_ptr<MultiProfileDownloadNotifier> notifier_;
};

TEST_F(MultiProfileDownloadNotifierTest, ProfileObservation) {
  // Make sure that profiles are not observed when they are filtered by
  // `ShouldObserveProfile()`.
  TestingProfile* profile = GetProfile();
  ON_CALL(client(), ShouldObserveProfile(profile))
      .WillByDefault(testing::Return(false));
  // Since `manager()`'s `IsManagerInitialized()` is mocked to return true,
  // `client()`'s `OnManagerInitialized()` would be called if the profile's
  // addition were not filtered.
  EXPECT_CALL(client(), OnManagerInitialized(manager())).Times(0);
  notifier()->AddProfile(profile);

  // Make sure that profiles are observed when they are not filtered by
  // `ShouldObserveProfile()`.
  ON_CALL(client(), ShouldObserveProfile(_))
      .WillByDefault(testing::Return(true));
  EXPECT_CALL(client(), OnManagerInitialized(manager()));
  notifier()->AddProfile(profile);

  // Make sure that off-the-record profiles are observed when spawned from an
  // observed profile.
  TestingProfile::Builder incognito_profile_builder;
  incognito_profile_builder.SetProfileName(profile->GetProfileUserName());
  EXPECT_CALL(client(), OnManagerInitialized(_));
  Profile* const incognito_profile =
      incognito_profile_builder.BuildIncognito(profile);

  // If `profile` and `incognito_profile` are being observed, `client()`'s
  // `OnManagerGoingDown()` should be called with each profile's download
  // manager when the profile goes out of scope.
  EXPECT_CALL(client(), OnManagerGoingDown(manager()));
  EXPECT_CALL(client(),
              OnManagerGoingDown(incognito_profile->GetDownloadManager()));
}

class MultiProfileDownloadNotifierManagerInitializationTest
    : public MultiProfileDownloadNotifierTest,
      public testing::WithParamInterface<
          std::tuple<bool /* should_initialize_manager */,
                     bool /* require_manager_initialization */>> {
 public:
  bool ShouldInitializeManager() override { return std::get<0>(GetParam()); }
  bool RequireManagerInitialization() override {
    return std::get<1>(GetParam());
  }
};

INSTANTIATE_TEST_SUITE_P(
    All,
    MultiProfileDownloadNotifierManagerInitializationTest,
    testing::Combine(/*should_initialize_manager=*/testing::Bool(),
                     /*require_manager_initialization=*/testing::Bool()));

TEST_P(MultiProfileDownloadNotifierManagerInitializationTest, ClientCalls) {
  TestingProfile* profile = GetProfile();
  ON_CALL(client(), ShouldObserveProfile(profile))
      .WillByDefault(testing::Return(true));
  notifier()->AddProfile(profile);

  EXPECT_CALL(client(), OnManagerInitialized(manager()));
  notifier_as_all_download_item_notifier_observer()->OnManagerInitialized(
      manager());

  // Make sure the OnDownload...() functions are not called when we require the
  // download manager to be initialized, but it is not.
  int num_calls_expected =
      !RequireManagerInitialization() || ShouldInitializeManager();

  EXPECT_CALL(client(), OnDownloadCreated(manager(), item()))
      .Times(num_calls_expected);
  notifier_as_all_download_item_notifier_observer()->OnDownloadCreated(
      manager(), item());

  EXPECT_CALL(client(), OnDownloadUpdated(manager(), item()))
      .Times(num_calls_expected);
  notifier_as_all_download_item_notifier_observer()->OnDownloadUpdated(
      manager(), item());

  EXPECT_CALL(client(), OnDownloadDestroyed(manager(), item()))
      .Times(num_calls_expected);
  notifier_as_all_download_item_notifier_observer()->OnDownloadDestroyed(
      manager(), item());

  EXPECT_CALL(client(), OnManagerGoingDown(manager()));
  notifier_as_all_download_item_notifier_observer()->OnManagerGoingDown(
      manager());
}

TEST_P(MultiProfileDownloadNotifierManagerInitializationTest,
       DownloadRetrieval) {
  TestingProfile* profile = GetProfile();
  ON_CALL(client(), ShouldObserveProfile(profile))
      .WillByDefault(testing::Return(true));
  notifier()->AddProfile(profile);

  // For each `MultiProfileDownloadNotifier` download retrieval function, mock
  // the `DownloadManager` function to which it ultimately forwards.
  std::vector<std::unique_ptr<content::FakeDownloadItem>> downloads;
  downloads.emplace_back(std::make_unique<content::FakeDownloadItem>());
  downloads.emplace_back(std::make_unique<content::FakeDownloadItem>());

  ON_CALL(*manager(), GetDownloadByGuid)
      .WillByDefault([&downloads](const std::string& guid) {
        return downloads.front().get();
      });
  auto* item = notifier()->GetDownloadByGuid("");
  // `GetDownloadByGuid()` ignores manager initialization status.
  EXPECT_EQ(item, downloads.front().get());

  ON_CALL(*manager(), GetAllDownloads)
      .WillByDefault(
          [&downloads](
              std::vector<raw_ptr<download::DownloadItem, VectorExperimental>>*
                  download_ptrs) {
            for (auto& download : downloads)
              download_ptrs->push_back(download.get());
          });
  auto retrieved_downloads = notifier()->GetAllDownloads();
  // `GetAllDownloads()` honors `client()`'s manager initialization requirement.
  EXPECT_EQ(retrieved_downloads.size(),
            !RequireManagerInitialization() || ShouldInitializeManager()
                ? downloads.size()
                : 0u);
}