Update from https://crrev.com/311076

net/sdch/sdch_owner_unittest.cc

+// 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 "base/memory/memory_pressure_listener.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/simple_test_clock.h"
+#include "net/base/net_log.h"
+#include "net/base/sdch_manager.h"
+#include "net/sdch/sdch_owner.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+static const char generic_url[] = "http://www.example.com";
+static const char generic_domain[] = "www.example.com";
+
+static std::string NewSdchDictionary(size_t dictionary_size) {
+  std::string dictionary;
+  dictionary.append("Domain: ");
+  dictionary.append(generic_domain);
+  dictionary.append("\n");
+  dictionary.append("\n");
+
+  size_t original_dictionary_size = dictionary.size();
+  dictionary.resize(dictionary_size);
+  for (size_t i = original_dictionary_size; i < dictionary_size; ++i)
+    dictionary[i] = static_cast<char>((i % 127) + 1);
+
+  return dictionary;
+}
+
+int outstanding_url_request_error_counting_jobs = 0;
+base::Closure* empty_url_request_jobs_callback = 0;
+
+// Variation of URLRequestErrorJob to count number of outstanding
+// instances and notify when that goes to zero.
+class URLRequestErrorCountingJob : public URLRequestJob {
+ public:
+  URLRequestErrorCountingJob(URLRequest* request,
+                             NetworkDelegate* network_delegate,
+                             int error)
+      : URLRequestJob(request, network_delegate),
+        error_(error),
+        weak_factory_(this) {
+    ++outstanding_url_request_error_counting_jobs;
+  }
+
+  void Start() override {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&URLRequestErrorCountingJob::StartAsync,
+                              weak_factory_.GetWeakPtr()));
+  }
+
+ private:
+  ~URLRequestErrorCountingJob() override {
+    --outstanding_url_request_error_counting_jobs;
+    if (0 == outstanding_url_request_error_counting_jobs &&
+        empty_url_request_jobs_callback) {
+      empty_url_request_jobs_callback->Run();
+    }
+  }
+
+  void StartAsync() {
+    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, error_));
+  }
+
+  int error_;
+
+  base::WeakPtrFactory<URLRequestErrorCountingJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestErrorCountingJob);
+};
+
+static int error_jobs_created = 0;
+
+class MockURLRequestJobFactory : public URLRequestJobFactory {
+ public:
+  MockURLRequestJobFactory() {}
+
+  ~MockURLRequestJobFactory() override {}
+
+  URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const override {
+    ++error_jobs_created;
+    return new URLRequestErrorCountingJob(request, network_delegate,
+                                          ERR_INTERNET_DISCONNECTED);
+  }
+
+  URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
+                                        NetworkDelegate* network_delegate,
+                                        const GURL& location) const override {
+    return nullptr;
+  }
+
+  URLRequestJob* MaybeInterceptResponse(
+      URLRequest* request,
+      NetworkDelegate* network_delegate) const override {
+    return nullptr;
+  }
+
+  bool IsHandledProtocol(const std::string& scheme) const override {
+    return scheme == "http";
+  };
+
+  bool IsHandledURL(const GURL& url) const override {
+    return url.SchemeIs("http");
+  }
+
+  bool IsSafeRedirectTarget(const GURL& location) const override {
+    return false;
+  }
+};
+
+class SdchOwnerTest : public testing::Test {
+ public:
+  static const size_t kMaxSizeForTesting = 1000 * 50;
+  static const size_t kMinFetchSpaceForTesting = 500;
+
+  SdchOwnerTest()
+      : last_jobs_created_(error_jobs_created),
+        dictionary_creation_index_(0),
+        sdch_owner_(&sdch_manager_, &url_request_context_) {
+    // Any jobs created on this context will immediately error,
+    // which leaves the test in control of signals to SdchOwner.
+    url_request_context_.set_job_factory(&job_factory_);
+
+    // Reduce sizes to reduce time for string operations.
+    sdch_owner_.SetMaxTotalDictionarySize(kMaxSizeForTesting);
+    sdch_owner_.SetMinSpaceForDictionaryFetch(kMinFetchSpaceForTesting);
+  }
+
+  SdchManager& sdch_manager() { return sdch_manager_; }
+  SdchOwner& sdch_owner() { return sdch_owner_; }
+  BoundNetLog& bound_net_log() { return net_log_; }
+
+  int JobsRecentlyCreated() {
+    int result = error_jobs_created - last_jobs_created_;
+    last_jobs_created_ = error_jobs_created;
+    return result;
+  }
+
+  bool DictionaryPresentInManager(const std::string& server_hash) {
+    // Presumes all tests use generic url.
+    SdchProblemCode tmp;
+    scoped_ptr<SdchManager::DictionarySet> set(
+        sdch_manager_.GetDictionarySetByHash(GURL(generic_url), server_hash,
+                                             &tmp));
+    return !!set.get();
+  }
+
+  void SignalGetDictionaryAndClearJobs(GURL request_url, GURL dictionary_url) {
+    sdch_owner().OnGetDictionary(&sdch_manager_, request_url, dictionary_url);
+    if (outstanding_url_request_error_counting_jobs == 0)
+      return;
+    base::RunLoop run_loop;
+    base::Closure quit_closure(run_loop.QuitClosure());
+    empty_url_request_jobs_callback = &quit_closure;
+    run_loop.Run();
+    empty_url_request_jobs_callback = NULL;
+  }
+
+  // Create a unique (by hash) dictionary of the given size,
+  // associate it with a unique URL, add it to the manager through
+  // SdchOwner::OnDictionaryFetched(), and return whether that
+  // addition was successful or not.
+  bool CreateAndAddDictionary(size_t size, std::string* server_hash_p) {
+    GURL dictionary_url(
+        base::StringPrintf("%s/d%d", generic_url, dictionary_creation_index_));
+    std::string dictionary_text(NewSdchDictionary(size - 4));
+    dictionary_text += base::StringPrintf("%04d", dictionary_creation_index_);
+    ++dictionary_creation_index_;
+    std::string client_hash;
+    std::string server_hash;
+    SdchManager::GenerateHash(dictionary_text, &client_hash, &server_hash);
+
+    if (DictionaryPresentInManager(server_hash))
+      return false;
+    sdch_owner().OnDictionaryFetched(dictionary_text, dictionary_url, net_log_);
+    if (server_hash_p)
+      *server_hash_p = server_hash;
+    return DictionaryPresentInManager(server_hash);
+  }
+
+ private:
+  int last_jobs_created_;
+  BoundNetLog net_log_;
+  int dictionary_creation_index_;
+
+  // The dependencies of these objects (sdch_owner_ -> {sdch_manager_,
+  // url_request_context_}, url_request_context_->job_factory_) require
+  // this order for correct destruction semantics.
+  MockURLRequestJobFactory job_factory_;
+  URLRequestContext url_request_context_;
+  SdchManager sdch_manager_;
+  SdchOwner sdch_owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(SdchOwnerTest);
+};
+
+// Does OnGetDictionary result in a fetch when there's enough space, and not
+// when there's not?
+TEST_F(SdchOwnerTest, OnGetDictionary_Fetching) {
+  GURL request_url(std::string(generic_url) + "/r1");
+
+  // Fetch generated when empty.
+  GURL dict_url1(std::string(generic_url) + "/d1");
+  EXPECT_EQ(0, JobsRecentlyCreated());
+  SignalGetDictionaryAndClearJobs(request_url, dict_url1);
+  EXPECT_EQ(1, JobsRecentlyCreated());
+
+  // Fetch generated when half full.
+  GURL dict_url2(std::string(generic_url) + "/d2");
+  std::string dictionary1(NewSdchDictionary(kMaxSizeForTesting / 2));
+  sdch_owner().OnDictionaryFetched(dictionary1, dict_url1, bound_net_log());
+  EXPECT_EQ(0, JobsRecentlyCreated());
+  SignalGetDictionaryAndClearJobs(request_url, dict_url2);
+  EXPECT_EQ(1, JobsRecentlyCreated());
+
+  // Fetch not generated when close to completely full.
+  GURL dict_url3(std::string(generic_url) + "/d3");
+  std::string dictionary2(NewSdchDictionary(
+      (kMaxSizeForTesting / 2 - kMinFetchSpaceForTesting / 2)));
+  sdch_owner().OnDictionaryFetched(dictionary2, dict_url2, bound_net_log());
+  EXPECT_EQ(0, JobsRecentlyCreated());
+  SignalGetDictionaryAndClearJobs(request_url, dict_url3);
+  EXPECT_EQ(0, JobsRecentlyCreated());
+}
+
+// Make sure attempts to add dictionaries do what they should.
+TEST_F(SdchOwnerTest, OnDictionaryFetched_Fetching) {
+  GURL request_url(std::string(generic_url) + "/r1");
+  std::string client_hash;
+  std::string server_hash;
+
+  // Add successful when empty.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_EQ(0, JobsRecentlyCreated());
+
+  // Add successful when half full.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_EQ(0, JobsRecentlyCreated());
+
+  // Add unsuccessful when full.
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting / 2, nullptr));
+  EXPECT_EQ(0, JobsRecentlyCreated());
+}
+
+// Confirm auto-eviction happens if space is needed.
+TEST_F(SdchOwnerTest, ConfirmAutoEviction) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+  std::string server_hash_d3;
+
+  // Add two dictionaries, one recent, one more than a day in the past.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1));
+
+  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d2));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+
+  // The addition of a new dictionary should succeed, evicting the old one.
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now());
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d3));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+}
+
+// Confirm auto-eviction happens if space is needed, with a more complicated
+// situation
+TEST_F(SdchOwnerTest, ConfirmAutoEviction_2) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+  std::string server_hash_d3;
+
+  // Add dictionaries, one recent, two more than a day in the past that
+  // between them add up to the space needed.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d1));
+
+  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+
+  // The addition of a new dictionary should succeed, evicting the old one.
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now());
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  std::string server_hash_d4;
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d3));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
+}
+
+// Confirm if only one dictionary needs to be evicted it's the oldest.
+TEST_F(SdchOwnerTest, ConfirmAutoEviction_Oldest) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+  std::string server_hash_d3;
+
+  // Add dictionaries, one recent, one two days in the past, and one
+  // four days in the past.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+
+  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+
+  // The addition of a new dictionary should succeed, evicting only the
+  // oldest one.
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now());
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  std::string server_hash_d4;
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d3));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
+}
+
+// Confirm using a dictionary changes eviction behavior properly.
+TEST_F(SdchOwnerTest, UseChangesEviction) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+  std::string server_hash_d3;
+
+  // Add dictionaries, one recent, one two days in the past, and one
+  // four days in the past.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+
+  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now());
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  // Use the oldest dictionary.
+  sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d3);
+
+  // The addition of a new dictionary should succeed, evicting only the
+  // newer stale one.
+  std::string server_hash_d4;
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d4));
+}
+
+// Confirm using a dictionary can prevent the addition of a new dictionary.
+TEST_F(SdchOwnerTest, UsePreventsAddition) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+  std::string server_hash_d3;
+
+  // Add dictionaries, one recent, one two days in the past, and one
+  // four days in the past.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d1));
+
+  scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(2));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d2));
+
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now() - base::TimeDelta::FromDays(4));
+  sdch_owner().SetClockForTesting(clock.Pass());
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 4, &server_hash_d3));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+
+  clock.reset(new base::SimpleTestClock);
+  clock->SetNow(base::Time::Now());
+  sdch_owner().SetClockForTesting(clock.Pass());
+
+  // Use the older dictionaries.
+  sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d2);
+  sdch_owner().OnDictionaryUsed(&sdch_manager(), server_hash_d3);
+
+  // The addition of a new dictionary should fail, not evicting anything.
+  std::string server_hash_d4;
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting / 2, &server_hash_d4));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d2));
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d3));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d4));
+}
+
+// Confirm clear gets all the space back.
+TEST_F(SdchOwnerTest, ClearReturnsSpace) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+
+  // Take up all the space.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1));
+
+  // Addition should fail.
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+
+  sdch_manager().ClearData();
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+
+  // Addition should now succeed.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, nullptr));
+}
+
+// Confirm memory pressure gets all the space back.
+TEST_F(SdchOwnerTest, MemoryPressureReturnsSpace) {
+  std::string server_hash_d1;
+  std::string server_hash_d2;
+
+  // Take up all the space.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d1));
+
+  // Addition should fail.
+  EXPECT_FALSE(CreateAndAddDictionary(kMaxSizeForTesting, &server_hash_d2));
+
+  EXPECT_TRUE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+
+  base::MemoryPressureListener::NotifyMemoryPressure(
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
+  // The notification may have (implementation note: does :-}) use a PostTask,
+  // so we drain the local message queue.  This should be safe (i.e. not have
+  // an inifinite number of messages) in a unit test.
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d1));
+  EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
+
+  // Addition should now succeed.
+  EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting, nullptr));
+}
+
+}  // namespace net