// Copyright 2014 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 "net/sdch/sdch_owner.h"

#include "base/bind.h"
#include "base/metrics/histogram_macros.h"
#include "base/time/default_clock.h"
#include "net/base/sdch_manager.h"
#include "net/base/sdch_net_log_params.h"

namespace {

enum DictionaryFate {
  // A Get-Dictionary header wasn't acted on.
  DICTIONARY_FATE_GET_IGNORED = 1,

  // A fetch was attempted, but failed.
  // TODO(rdsmith): Actually record this case.
  DICTIONARY_FATE_FETCH_FAILED = 2,

  // A successful fetch was dropped on the floor, no space.
  DICTIONARY_FATE_FETCH_IGNORED_NO_SPACE = 3,

  // A successful fetch was refused by the SdchManager.
  DICTIONARY_FATE_FETCH_MANAGER_REFUSED = 4,

  // A dictionary was successfully added.
  DICTIONARY_FATE_ADDED = 5,

  // A dictionary was evicted by an incoming dict.
  DICTIONARY_FATE_EVICT_FOR_DICT = 6,

  // A dictionary was evicted by memory pressure.
  DICTIONARY_FATE_EVICT_FOR_MEMORY = 7,

  // A dictionary was evicted on destruction.
  DICTIONARY_FATE_EVICT_FOR_DESTRUCTION = 8,

  DICTIONARY_FATE_MAX = 9
};

void RecordDictionaryFate(enum DictionaryFate fate) {
  UMA_HISTOGRAM_ENUMERATION("Sdch3.DictionaryFate", fate, DICTIONARY_FATE_MAX);
}

void RecordDictionaryEviction(int use_count, DictionaryFate fate) {
  DCHECK(fate == DICTIONARY_FATE_EVICT_FOR_DICT ||
         fate == DICTIONARY_FATE_EVICT_FOR_MEMORY ||
         fate == DICTIONARY_FATE_EVICT_FOR_DESTRUCTION);

  UMA_HISTOGRAM_COUNTS_100("Sdch3.DictionaryUseCount", use_count);
  RecordDictionaryFate(fate);
}

}  // namespace

namespace net {

// Adjust SDCH limits downwards for mobile.
#if defined(OS_ANDROID) || defined(OS_IOS)
// static
const size_t SdchOwner::kMaxTotalDictionarySize = 1000 * 1000;
#else
// static
const size_t SdchOwner::kMaxTotalDictionarySize = 20 * 1000 * 1000;
#endif

// Somewhat arbitrary, but we assume a dictionary smaller than
// 50K isn't going to do anyone any good.  Note that this still doesn't
// prevent download and addition unless there is less than this
// amount of space available in storage.
const size_t SdchOwner::kMinSpaceForDictionaryFetch = 50 * 1000;

SdchOwner::SdchOwner(net::SdchManager* sdch_manager,
                     net::URLRequestContext* context)
    : manager_(sdch_manager),
      fetcher_(context,
               base::Bind(&SdchOwner::OnDictionaryFetched,
                          // Because |fetcher_| is owned by SdchOwner, the
                          // SdchOwner object will be available for the lifetime
                          // of |fetcher_|.
                          base::Unretained(this))),
      total_dictionary_bytes_(0),
      clock_(new base::DefaultClock),
      max_total_dictionary_size_(kMaxTotalDictionarySize),
      min_space_for_dictionary_fetch_(kMinSpaceForDictionaryFetch),
      memory_pressure_listener_(
          base::Bind(&SdchOwner::OnMemoryPressure,
                     // Because |memory_pressure_listener_| is owned by
                     // SdchOwner, the SdchOwner object will be available
                     // for the lifetime of |memory_pressure_listener_|.
                     base::Unretained(this))) {
  manager_->AddObserver(this);
}

SdchOwner::~SdchOwner() {
  for (auto it = local_dictionary_info_.begin();
       it != local_dictionary_info_.end(); ++it) {
    RecordDictionaryEviction(it->second.use_count,
                             DICTIONARY_FATE_EVICT_FOR_DESTRUCTION);
  }
  manager_->RemoveObserver(this);
}

void SdchOwner::SetMaxTotalDictionarySize(size_t max_total_dictionary_size) {
  max_total_dictionary_size_ = max_total_dictionary_size;
}

void SdchOwner::SetMinSpaceForDictionaryFetch(
    size_t min_space_for_dictionary_fetch) {
  min_space_for_dictionary_fetch_ = min_space_for_dictionary_fetch;
}

void SdchOwner::OnDictionaryFetched(const std::string& dictionary_text,
                                    const GURL& dictionary_url,
                                    const net::BoundNetLog& net_log) {
  struct DictionaryItem {
    base::Time last_used;
    std::string server_hash;
    int use_count;
    size_t dictionary_size;

    DictionaryItem() : use_count(0), dictionary_size(0) {}
    DictionaryItem(const base::Time& last_used,
                   const std::string& server_hash,
                   int use_count,
                   size_t dictionary_size)
        : last_used(last_used),
          server_hash(server_hash),
          use_count(use_count),
          dictionary_size(dictionary_size) {}
    DictionaryItem(const DictionaryItem& rhs) = default;
    DictionaryItem& operator=(const DictionaryItem& rhs) = default;
    bool operator<(const DictionaryItem& rhs) const {
      return last_used < rhs.last_used;
    }
  };

  std::vector<DictionaryItem> stale_dictionary_list;
  size_t recoverable_bytes = 0;
  base::Time stale_boundary(clock_->Now() - base::TimeDelta::FromDays(1));
  for (auto used_it = local_dictionary_info_.begin();
       used_it != local_dictionary_info_.end(); ++used_it) {
    if (used_it->second.last_used < stale_boundary) {
      stale_dictionary_list.push_back(
          DictionaryItem(used_it->second.last_used, used_it->first,
                         used_it->second.use_count, used_it->second.size));
      recoverable_bytes += used_it->second.size;
    }
  }

  if (total_dictionary_bytes_ + dictionary_text.size() - recoverable_bytes >
      max_total_dictionary_size_) {
    RecordDictionaryFate(DICTIONARY_FATE_FETCH_IGNORED_NO_SPACE);
    net::SdchManager::SdchErrorRecovery(SDCH_DICTIONARY_NO_ROOM);
    net_log.AddEvent(net::NetLog::TYPE_SDCH_DICTIONARY_ERROR,
                     base::Bind(&net::NetLogSdchDictionaryFetchProblemCallback,
                                SDCH_DICTIONARY_NO_ROOM, dictionary_url, true));
    return;
  }

  // Evict from oldest to youngest until we have space.
  std::sort(stale_dictionary_list.begin(), stale_dictionary_list.end());
  size_t avail_bytes = max_total_dictionary_size_ - total_dictionary_bytes_;
  auto stale_it = stale_dictionary_list.begin();
  while (avail_bytes < dictionary_text.size() &&
         stale_it != stale_dictionary_list.end()) {
    manager_->RemoveSdchDictionary(stale_it->server_hash);
    RecordDictionaryEviction(stale_it->use_count,
                             DICTIONARY_FATE_EVICT_FOR_DICT);
    local_dictionary_info_.erase(stale_it->server_hash);
    avail_bytes += stale_it->dictionary_size;
    ++stale_it;
  }
  DCHECK(avail_bytes >= dictionary_text.size());

  std::string server_hash;
  net::SdchProblemCode rv = manager_->AddSdchDictionary(
      dictionary_text, dictionary_url, &server_hash);
  if (rv != net::SDCH_OK) {
    RecordDictionaryFate(DICTIONARY_FATE_FETCH_MANAGER_REFUSED);
    net::SdchManager::SdchErrorRecovery(rv);
    net_log.AddEvent(net::NetLog::TYPE_SDCH_DICTIONARY_ERROR,
                     base::Bind(&net::NetLogSdchDictionaryFetchProblemCallback,
                                rv, dictionary_url, true));
    return;
  }

  RecordDictionaryFate(DICTIONARY_FATE_ADDED);

  DCHECK(local_dictionary_info_.end() ==
         local_dictionary_info_.find(server_hash));
  total_dictionary_bytes_ += dictionary_text.size();
  local_dictionary_info_[server_hash] = DictionaryInfo(
      // Set the time last used to something to avoid thrashing, but not recent,
      // to avoid taking too much time/space with useless dictionaries/one-off
      // visits to web sites.
      clock_->Now() - base::TimeDelta::FromHours(23), dictionary_text.size());
}

void SdchOwner::OnDictionaryUsed(SdchManager* manager,
                                 const std::string& server_hash) {
  auto it = local_dictionary_info_.find(server_hash);
  DCHECK(local_dictionary_info_.end() != it);

  it->second.last_used = clock_->Now();
  it->second.use_count++;
}

void SdchOwner::OnGetDictionary(net::SdchManager* manager,
                                const GURL& request_url,
                                const GURL& dictionary_url) {
  base::Time stale_boundary(clock_->Now() - base::TimeDelta::FromDays(1));
  size_t avail_bytes = 0;
  for (auto it = local_dictionary_info_.begin();
       it != local_dictionary_info_.end(); ++it) {
    if (it->second.last_used < stale_boundary)
      avail_bytes += it->second.size;
  }

  // Don't initiate the fetch if we wouldn't be able to store any
  // reasonable dictionary.
  // TODO(rdsmith): Maybe do a HEAD request to figure out how much
  // storage we'd actually need?
  if (max_total_dictionary_size_ < (total_dictionary_bytes_ - avail_bytes +
                                    min_space_for_dictionary_fetch_)) {
    RecordDictionaryFate(DICTIONARY_FATE_GET_IGNORED);
    // TODO(rdsmith): Log a net-internals error.  This requires
    // SdchManager to forward the URLRequest that detected the
    // Get-Dictionary header to its observers, which is tricky
    // because SdchManager is layered underneath URLRequest.
    return;
  }

  fetcher_.Schedule(dictionary_url);
}

void SdchOwner::OnClearDictionaries(net::SdchManager* manager) {
  total_dictionary_bytes_ = 0;
  local_dictionary_info_.clear();
  fetcher_.Cancel();
}

void SdchOwner::SetClockForTesting(scoped_ptr<base::Clock> clock) {
  clock_ = clock.Pass();
}

void SdchOwner::OnMemoryPressure(
    base::MemoryPressureListener::MemoryPressureLevel level) {
  DCHECK_NE(base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, level);

  for (auto it = local_dictionary_info_.begin();
       it != local_dictionary_info_.end(); ++it) {
    RecordDictionaryEviction(it->second.use_count,
                             DICTIONARY_FATE_EVICT_FOR_MEMORY);
  }

  // TODO(rdsmith): Make a distinction between moderate and critical
  // memory pressure.
  manager_->ClearData();
}

}  // namespace net