Deflake origin trial token validator tests

content/browser/service_worker/foreign_fetch_request_handler_unittest.cc

 // Copyright 2016 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 "content/browser/service_worker/foreign_fetch_request_handler.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/origin_trial_policy.h"
@@ skipping 24 matching lines @@
 const uint8_t kTestPublicKey[] = {
     0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
     0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
     0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
 };
 
 int kMockProviderId = 1;
 
 const char* kValidUrl = "https://valid.example.com/foo/bar";
 
+// This timestamp is set to a time after the expiry timestamp of the expired
+// tokens in this test, but before the expiry timestamp of the valid ones.
+double kNowTimestamp = 1500000000;
+
 void EmptyCallback() {}
 
 }  // namespace
 
 class ForeignFetchRequestHandlerTest : public testing::Test {
  public:
   ForeignFetchRequestHandlerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {
     SetContentClient(&test_content_client_);
     SetBrowserClientForTesting(&test_content_browser_client_);
   }
   ~ForeignFetchRequestHandlerTest() override {}
 
   void SetUp() override {
     const GURL kScope("https://valid.example.com/scope/");
     const GURL kResource1("https://valid.example.com/scope/sw.js");
     const int64_t kRegistrationId = 0;
     const int64_t kVersionId = 0;
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
     // Create a registration for the worker which has foreign fetch event
     // handler.
     registration_ =
         new ServiceWorkerRegistration(ServiceWorkerRegistrationOptions(kScope),
                                       kRegistrationId, context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(registration_.get(), kResource1,
                                         kVersionId, context()->AsWeakPtr());
     version_->set_foreign_fetch_scopes({kScope});
 
+    // Fix the time for testing to kNowTimestamp
+    base::SimpleTestClock* clock = new base::SimpleTestClock();
+    clock->SetNow(base::Time::FromDoubleT(kNowTimestamp));
+    version_->SetClockForTesting(base::WrapUnique(clock));

[Marijn Kruisselbrink, 2017/08/02 19:57:25]

why WrapUnique here, and not simply base::MakeUnique where you create the
instance?

[iclelland, 2017/08/02 20:22:05]

Because I need to call SetNow() on it -- if I make it a unique_ptr<Clock>, then
I have to do a cludgy cast on the pointer immediately to call SimpleTestClock
methods -- and if I make a unique_ptr<SimpleTestClock>, then I can't pass that
to SetClockForTesting, since std::unique_ptr<base::SimpleTestClock> is not a
subclass of std::unique_ptr<base::Clock>

(On the other hand, it turns out that I can std::move() the test clock, and the
compiler is okay with that -- does that seem better than a raw pointer
temporary?)

[Marijn Kruisselbrink, 2017/08/02 20:34:20]

Yeah, that's what I meant. std::unique_ptr<Foo> is implicitly convertible to
std::unique_ptr<Bar> iff Foo* is implicitly convertible to Bar*

+
     context()->storage()->LazyInitialize(base::Bind(&EmptyCallback));
     base::RunLoop().RunUntilIdle();
 
     // Persist the registration data.
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
     version_->script_cache_map()->SetResources(records);
     version_->set_fetch_handler_existence(
         ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
@@ skipping 292 matching lines @@
   // Make sure new request only gets remaining timeout.
   ForeignFetchRequestHandler* handler =
       InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE,
                         nullptr /* initiator */);
   ASSERT_TRUE(handler);
   ASSERT_TRUE(timeout_for_request(handler).has_value());
   EXPECT_EQ(remaining_time, timeout_for_request(handler).value());
 }
 
 }  // namespace content