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

#include "chrome/browser/resource_coordinator/tab_manager_features.h"

#include "base/macros.h"
#include "base/metrics/field_trial.h"
#include "base/strings/string_piece.h"
#include "components/variations/variations_params_manager.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace resource_coordinator {

namespace {

class TabManagerFeaturesTest : public testing::Test {
 public:
  // Enables the proactive tab discarding feature, and sets up the associated
  // variations parameter values.
  void EnableProactiveTabFreezeAndDiscard() {
    std::set<std::string> features;
    features.insert(features::kProactiveTabFreezeAndDiscard.name);
    variations_manager_.SetVariationParamsWithFeatureAssociations(
        "DummyTrial", params_, features);
  }

  // Enables the site characteristics database feature, and sets up the
  // associated variations parameter values.
  void EnableSiteCharacteristicsDatabase() {
    std::set<std::string> features;
    features.insert(features::kSiteCharacteristicsDatabase.name);
    variations_manager_.SetVariationParamsWithFeatureAssociations(
        "DummyTrial", params_, features);
  }

  // Enables the site characteristics database feature, and sets up the
  // associated variations parameter values.
  void EnableInfiniteSessionRestore() {
    std::set<std::string> features;
    features.insert(features::kInfiniteSessionRestore.name);
    variations_manager_.SetVariationParamsWithFeatureAssociations(
        "DummyTrial", params_, features);
  }

  void SetParam(base::StringPiece key, base::StringPiece value) {
    params_[key.as_string()] = value.as_string();
  }

  void ExpectProactiveTabFreezeAndDiscardParams(
      bool should_proactively_discard,
      bool should_periodically_unfreeze,
      bool should_protect_tabs_sharing_browsing_instance,
      int low_loaded_tab_count,
      int moderate_loaded_tab_count,
      int high_loaded_tab_count,
      int memory_in_gb,
      base::TimeDelta low_occluded_timeout,
      base::TimeDelta moderate_occluded_timeout,
      base::TimeDelta high_occluded_timeout,
      base::TimeDelta freeze_timeout,
      base::TimeDelta unfreeze_timeout,
      base::TimeDelta refreeze_timeout,
      bool disable_heuristics_protections) {
    ProactiveTabFreezeAndDiscardParams params =
        GetProactiveTabFreezeAndDiscardParams(memory_in_gb);

    EXPECT_EQ(should_proactively_discard, params.should_proactively_discard);
    EXPECT_EQ(should_periodically_unfreeze,
              params.should_periodically_unfreeze);
    EXPECT_EQ(should_protect_tabs_sharing_browsing_instance,
              params.should_protect_tabs_sharing_browsing_instance);
    EXPECT_EQ(low_loaded_tab_count, params.low_loaded_tab_count);
    EXPECT_EQ(moderate_loaded_tab_count, params.moderate_loaded_tab_count);

    // Enforce that |moderate_loaded_tab_count| is within [low_loaded_tab_count,
    // high_loaded_tab_count].
    EXPECT_GE(params.moderate_loaded_tab_count, params.low_loaded_tab_count);
    EXPECT_LE(params.moderate_loaded_tab_count, params.high_loaded_tab_count);

    EXPECT_EQ(high_loaded_tab_count, params.high_loaded_tab_count);
    EXPECT_EQ(low_occluded_timeout, params.low_occluded_timeout);
    EXPECT_EQ(moderate_occluded_timeout, params.moderate_occluded_timeout);
    EXPECT_EQ(high_occluded_timeout, params.high_occluded_timeout);

    EXPECT_EQ(freeze_timeout, params.freeze_timeout);
    EXPECT_EQ(unfreeze_timeout, params.unfreeze_timeout);
    EXPECT_EQ(refreeze_timeout, params.refreeze_timeout);

    EXPECT_EQ(disable_heuristics_protections,
              params.disable_heuristics_protections);
  }

  void ExpectSiteCharacteristicsDatabaseParams(
      base::TimeDelta favicon_update_observation_window,
      base::TimeDelta title_update_observation_window,
      base::TimeDelta audio_usage_observation_window,
      base::TimeDelta notifications_usage_observation_window,
      base::TimeDelta title_or_favicon_change_grace_period,
      base::TimeDelta audio_usage_grace_period) {
    SiteCharacteristicsDatabaseParams params =
        GetSiteCharacteristicsDatabaseParams();

    EXPECT_EQ(favicon_update_observation_window,
              params.favicon_update_observation_window);
    EXPECT_EQ(title_update_observation_window,
              params.title_update_observation_window);
    EXPECT_EQ(audio_usage_observation_window,
              params.audio_usage_observation_window);
    EXPECT_EQ(notifications_usage_observation_window,
              params.notifications_usage_observation_window);
    EXPECT_EQ(title_or_favicon_change_grace_period,
              params.title_or_favicon_change_grace_period);
    EXPECT_EQ(audio_usage_grace_period, params.audio_usage_grace_period);
  }

  void ExpectInfiniteSessionRestoreParams(
      uint32_t min_simultaneous_tab_loads,
      uint32_t max_simultaneous_tab_loads,
      uint32_t cores_per_simultaneous_tab_load,
      uint32_t min_tabs_to_restore,
      uint32_t max_tabs_to_restore,
      uint32_t mb_free_memory_per_tab_to_restore,
      base::TimeDelta max_time_since_last_use_to_restore,
      uint32_t min_site_engagement_to_restore) {
    InfiniteSessionRestoreParams params = GetInfiniteSessionRestoreParams();
    EXPECT_EQ(min_simultaneous_tab_loads, params.min_simultaneous_tab_loads);
    EXPECT_EQ(max_simultaneous_tab_loads, params.max_simultaneous_tab_loads);
    EXPECT_EQ(cores_per_simultaneous_tab_load,
              params.cores_per_simultaneous_tab_load);
    EXPECT_EQ(min_tabs_to_restore, params.min_tabs_to_restore);
    EXPECT_EQ(max_tabs_to_restore, params.max_tabs_to_restore);
    EXPECT_EQ(mb_free_memory_per_tab_to_restore,
              params.mb_free_memory_per_tab_to_restore);
    EXPECT_EQ(max_time_since_last_use_to_restore,
              params.max_time_since_last_use_to_restore);
    EXPECT_EQ(min_site_engagement_to_restore,
              params.min_site_engagement_to_restore);
  }

  void ExpectDefaultProactiveTabFreezeAndDiscardParams() {
    int memory_in_gb = 4;
    ExpectProactiveTabFreezeAndDiscardParams(
        ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard
            .default_value,
        ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze
            .default_value,
        ProactiveTabFreezeAndDiscardParams::
            kShouldProtectTabsSharingBrowsingInstance.default_value,
        ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.default_value,
        ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam
                .default_value *
            memory_in_gb,
        ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.default_value,
        memory_in_gb,
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout
                .default_value),
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout
                .default_value),
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout
                .default_value),
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.default_value),
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.default_value),
        base::TimeDelta::FromSeconds(
            ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.default_value),
        ProactiveTabFreezeAndDiscardParams::kDisableHeuristicsProtections
            .default_value);
  }

  void ExpectDefaultSiteCharacteristicsDatabaseParams() {
    ExpectSiteCharacteristicsDatabaseParams(
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow
                .default_value),
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow
                .default_value),
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow
                .default_value),
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::
                kNotificationsUsageObservationWindow.default_value),
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod
                .default_value),
        base::TimeDelta::FromSeconds(
            SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod
                .default_value));
  }

  void ExpectDefaultInfiniteSessionRestoreParams() {
    ExpectInfiniteSessionRestoreParams(
        InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.default_value,
        InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.default_value,
        InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad
            .default_value,
        InfiniteSessionRestoreParams::kMinTabsToRestore.default_value,
        InfiniteSessionRestoreParams::kMaxTabsToRestore.default_value,
        InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore
            .default_value,
        base::TimeDelta::FromSeconds(
            InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore
                .default_value),
        InfiniteSessionRestoreParams::kMinSiteEngagementToRestore
            .default_value);
  }

 private:
  std::map<std::string, std::string> params_;
  variations::testing::VariationParamsManager variations_manager_;
};

}  // namespace

TEST_F(TabManagerFeaturesTest,
       GetProactiveTabFreezeAndDiscardParamsDisabledFeatureGoesToDefault) {
  // Do not enable the proactive tab discarding feature.
  ExpectDefaultProactiveTabFreezeAndDiscardParams();
}

TEST_F(TabManagerFeaturesTest,
       GetProactiveTabFreezeAndDiscardParamsNoneGoesToDefault) {
  EnableProactiveTabFreezeAndDiscard();
  ExpectDefaultProactiveTabFreezeAndDiscardParams();
}

TEST_F(TabManagerFeaturesTest,
       GetProactiveTabFreezeAndDiscardParamsInvalidGoesToDefault) {
  SetParam(ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard.name,
           "blah");
  SetParam(ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze.name,
           "blah");
  SetParam(ProactiveTabFreezeAndDiscardParams::
               kShouldProtectTabsSharingBrowsingInstance.name,
           "bleh");
  SetParam(ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.name, "ab");
  SetParam(ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam.name,
           "27.8");
  SetParam(ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.name, "4e8");
  SetParam(ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout.name, "---");
  SetParam(ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout.name,
           " ");
  SetParam(ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout.name, "");
  SetParam(ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.name, "b");
  SetParam(ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.name, "i");
  SetParam(ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.name, "m");
  SetParam(
      ProactiveTabFreezeAndDiscardParams::kDisableHeuristicsProtections.name,
      "bleh");
  EnableProactiveTabFreezeAndDiscard();
  ExpectDefaultProactiveTabFreezeAndDiscardParams();
}

TEST_F(TabManagerFeaturesTest, GetProactiveTabFreezeAndDiscardParams) {
  SetParam(ProactiveTabFreezeAndDiscardParams::kShouldProactivelyDiscard.name,
           "true");
  SetParam(ProactiveTabFreezeAndDiscardParams::kShouldPeriodicallyUnfreeze.name,
           "true");
  SetParam(ProactiveTabFreezeAndDiscardParams::
               kShouldProtectTabsSharingBrowsingInstance.name,
           "true");
  SetParam(ProactiveTabFreezeAndDiscardParams::kLowLoadedTabCount.name, "7");
  SetParam(ProactiveTabFreezeAndDiscardParams::kModerateLoadedTabsPerGbRam.name,
           "4");
  SetParam(ProactiveTabFreezeAndDiscardParams::kHighLoadedTabCount.name, "42");
  // These are expressed in seconds.
  SetParam(ProactiveTabFreezeAndDiscardParams::kLowOccludedTimeout.name, "60");
  SetParam(ProactiveTabFreezeAndDiscardParams::kModerateOccludedTimeout.name,
           "120");
  SetParam(ProactiveTabFreezeAndDiscardParams::kHighOccludedTimeout.name,
           "247");
  SetParam(ProactiveTabFreezeAndDiscardParams::kFreezeTimeout.name, "10");
  SetParam(ProactiveTabFreezeAndDiscardParams::kUnfreezeTimeout.name, "20");
  SetParam(ProactiveTabFreezeAndDiscardParams::kRefreezeTimeout.name, "30");
  SetParam(
      ProactiveTabFreezeAndDiscardParams::kDisableHeuristicsProtections.name,
      "true");
  EnableProactiveTabFreezeAndDiscard();

  // Should snap |moderate_loaded_tab_count| to |low_loaded_tab_count|, when the
  // amount of physical memory is so low that (|memory_in_gb| *
  // |moderate_tab_count_per_gb_ram|) < |low_loaded_tab_count|).
  int memory_in_gb_low = 1;
  ExpectProactiveTabFreezeAndDiscardParams(
      true, true, true, 7, 7, 42, memory_in_gb_low,
      base::TimeDelta::FromSeconds(60), base::TimeDelta::FromSeconds(120),
      base::TimeDelta::FromSeconds(247), base::TimeDelta::FromSeconds(10),
      base::TimeDelta::FromSeconds(20), base::TimeDelta::FromSeconds(30), true);

  // Should snap |moderate_loaded_tab_count| to |high_loaded_tab_count|, when
  // the amount of physical memory is so high that (|memory_in_gb| *
  // |moderate_tab_count_per_gb_ram|) > |high_loaded_tab_count|).
  int memory_in_gb_high = 100;
  ExpectProactiveTabFreezeAndDiscardParams(
      true, true, true, 7, 42, 42, memory_in_gb_high,
      base::TimeDelta::FromSeconds(60), base::TimeDelta::FromSeconds(120),
      base::TimeDelta::FromSeconds(247), base::TimeDelta::FromSeconds(10),
      base::TimeDelta::FromSeconds(20), base::TimeDelta::FromSeconds(30), true);

  // Tests normal case where |memory_in gb| * |moderate_tab_count_per_gb_ram| is
  // in the interval [low_loaded_tab_count, high_loaded_tab_count].
  int memory_in_gb_normal = 4;
  ExpectProactiveTabFreezeAndDiscardParams(
      true, true, true, 7, 16, 42, memory_in_gb_normal,
      base::TimeDelta::FromSeconds(60), base::TimeDelta::FromSeconds(120),
      base::TimeDelta::FromSeconds(247), base::TimeDelta::FromSeconds(10),
      base::TimeDelta::FromSeconds(20), base::TimeDelta::FromSeconds(30), true);
}

TEST_F(TabManagerFeaturesTest,
       GetSiteCharacteristicsDatabaseParamsDisabledFeatureGoesToDefault) {
  // Do not enable the site characteristics database.
  ExpectDefaultSiteCharacteristicsDatabaseParams();
}

TEST_F(TabManagerFeaturesTest,
       GetSiteCharacteristicsDatabaseParamsParamsNoneGoesToDefault) {
  ExpectDefaultSiteCharacteristicsDatabaseParams();
}

TEST_F(TabManagerFeaturesTest,
       GetSiteCharacteristicsDatabaseParamsInvalidGoesToDefault) {
  SetParam(
      SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow.name,
      "    ");
  SetParam(
      SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow.name,
      "foo");
  SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow.name,
           ".");
  SetParam(
      SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow
          .name,
      "abc");
  SetParam(
      SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod.name,
      "bleh");
  SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod.name,
           "!!!");
  EnableSiteCharacteristicsDatabase();
  ExpectDefaultSiteCharacteristicsDatabaseParams();
}

TEST_F(TabManagerFeaturesTest, GetSiteCharacteristicsDatabaseParams) {
  SetParam(
      SiteCharacteristicsDatabaseParams::kFaviconUpdateObservationWindow.name,
      "3600");
  SetParam(
      SiteCharacteristicsDatabaseParams::kTitleUpdateObservationWindow.name,
      "36000");
  SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageObservationWindow.name,
           "360000");
  SetParam(
      SiteCharacteristicsDatabaseParams::kNotificationsUsageObservationWindow
          .name,
      "3600000");
  SetParam(
      SiteCharacteristicsDatabaseParams::kTitleOrFaviconChangeGracePeriod.name,
      "42");
  SetParam(SiteCharacteristicsDatabaseParams::kAudioUsageGracePeriod.name,
           "43");

  EnableSiteCharacteristicsDatabase();

  ExpectSiteCharacteristicsDatabaseParams(
      base::TimeDelta::FromSeconds(3600), base::TimeDelta::FromSeconds(36000),
      base::TimeDelta::FromSeconds(360000),
      base::TimeDelta::FromSeconds(3600000), base::TimeDelta::FromSeconds(42),
      base::TimeDelta::FromSeconds(43));
}

TEST_F(TabManagerFeaturesTest,
       GetInfiniteSessionRestoreParamsInvalidGoesToDefault) {
  SetParam(InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.name, "  ");
  SetParam(InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.name, "a.b");
  SetParam(InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.name,
           "-- ");
  SetParam(InfiniteSessionRestoreParams::kMinTabsToRestore.name, "hey");
  SetParam(InfiniteSessionRestoreParams::kMaxTabsToRestore.name, ".");
  SetParam(InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.name,
           "0x0");
  SetParam(InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.name,
           "foo");
  SetParam(InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.name,
           "bar");
  EnableInfiniteSessionRestore();
  ExpectDefaultInfiniteSessionRestoreParams();
}

TEST_F(TabManagerFeaturesTest, GetInfiniteSessionRestoreParams) {
  SetParam(InfiniteSessionRestoreParams::kMinSimultaneousTabLoads.name, "10");
  SetParam(InfiniteSessionRestoreParams::kMaxSimultaneousTabLoads.name, "20");
  SetParam(InfiniteSessionRestoreParams::kCoresPerSimultaneousTabLoad.name,
           "2");
  SetParam(InfiniteSessionRestoreParams::kMinTabsToRestore.name, "13");
  SetParam(InfiniteSessionRestoreParams::kMaxTabsToRestore.name, "27");
  SetParam(InfiniteSessionRestoreParams::kMbFreeMemoryPerTabToRestore.name,
           "1337");
  SetParam(InfiniteSessionRestoreParams::kMaxTimeSinceLastUseToRestore.name,
           "60");
  SetParam(InfiniteSessionRestoreParams::kMinSiteEngagementToRestore.name, "9");
  EnableInfiniteSessionRestore();
  ExpectInfiniteSessionRestoreParams(10, 20, 2, 13, 27, 1337,
                                     base::TimeDelta::FromMinutes(1), 9);
}

}  // namespace resource_coordinator