Limit timeout for foreign fetch events when triggered by another service worker.

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_tick_clock.h"
 #include "content/browser/browser_thread_impl.h"
+#include "content/browser/fileapi/mock_url_request_delegate.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"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/test/test_content_browser_client.h"
 #include "net/http/http_response_info.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
+#include "net/url_request/url_request_context.h"
+#include "storage/browser/blob/blob_storage_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 // This is a sample public key for testing the API. The corresponding private
 // key (use this to generate new samples for this test file) is:
 //
 //  0x83, 0x67, 0xf4, 0xcd, 0x2a, 0x1f, 0x0e, 0x04, 0x0d, 0x43, 0x13,
 //  0x4c, 0x67, 0xc4, 0xf4, 0x28, 0xc9, 0x90, 0x15, 0x02, 0xe2, 0xba,
 //  0xfd, 0xbb, 0xfa, 0xbc, 0x92, 0x76, 0x8a, 0x2c, 0x4b, 0xc7, 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
 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";
+
+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()));
     registration_ = new ServiceWorkerRegistration(kScope, kRegistrationId,
                                                   context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(registration_.get(), kResource1,
                                         kVersionId, context()->AsWeakPtr());
+
+    version_->set_foreign_fetch_scopes({kScope});
+
+    // An empty host.
+    std::unique_ptr<ServiceWorkerProviderHost> host(
+        new ServiceWorkerProviderHost(
+            helper_->mock_render_process_id(), MSG_ROUTING_NONE,
+            kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+            ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
+            context()->AsWeakPtr(), nullptr));
+    host->SetDocumentUrl(GURL("https://host/scope/"));
+    provider_host_ = host->AsWeakPtr();
+    context()->AddProviderHost(std::move(host));
+
+    context()->storage()->LazyInitialize(base::Bind(&EmptyCallback));
+    base::RunLoop().RunUntilIdle();
+
+    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);
+    version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
+    registration_->SetActiveVersion(version_);
+    context()->storage()->StoreRegistration(
+        registration_.get(), version_.get(),
+        base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+    base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     version_ = nullptr;
     registration_ = nullptr;
     helper_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   ServiceWorkerContextCore* context() const { return helper_->context(); }
+  ServiceWorkerContextWrapper* context_wrapper() const {
+    return helper_->context_wrapper();
+  }
+  ServiceWorkerProviderHost* provider_host() const {
+    return provider_host_.get();
+  }
 
   bool CheckOriginTrialToken(const ServiceWorkerVersion* const version) const {
     return ForeignFetchRequestHandler::CheckOriginTrialToken(version);
   }
 
+  base::Optional<base::TimeDelta> timeout_for_request(
+      ForeignFetchRequestHandler* handler) {
+    return handler->timeout_;
+  }
+
   ServiceWorkerVersion* version() const { return version_.get(); }
 
   static std::unique_ptr<net::HttpResponseInfo> CreateTestHttpResponseInfo() {
     std::unique_ptr<net::HttpResponseInfo> http_info(
         base::MakeUnique<net::HttpResponseInfo>());
     http_info->ssl_info.cert =
         net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
     DCHECK(http_info->ssl_info.is_valid());
     http_info->ssl_info.security_bits = 0x100;
     // SSL3 TLS_DHE_RSA_WITH_AES_256_CBC_SHA
     http_info->ssl_info.connection_status = 0x300039;
     http_info->headers = make_scoped_refptr(new net::HttpResponseHeaders(""));
     return http_info;
   }
 
+  ForeignFetchRequestHandler* InitializeHandler(const std::string& url,
+                                                ResourceType resource_type,
+                                                const char* initiator) {
+    request_ = url_request_context_.CreateRequest(
+        GURL(url), net::DEFAULT_PRIORITY, &url_request_delegate_);
+    if (initiator)
+      request_->set_initiator(url::Origin(GURL(initiator)));
+    ForeignFetchRequestHandler::InitializeHandler(
+        request_.get(), context_wrapper(), &blob_storage_context_,
+        helper_->mock_render_process_id(), kMockProviderId,
+        SkipServiceWorker::NONE, FETCH_REQUEST_MODE_CORS,
+        FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE,
+        resource_type, REQUEST_CONTEXT_TYPE_FETCH,
+        REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr,
+        true /* initiated_in_secure_context */);
+
+    return ForeignFetchRequestHandler::GetHandler(request_.get());
+  }
+
+  void CreateServiceWorkerTypeProviderHost() {
+    std::unique_ptr<ServiceWorkerProviderHost> host(
+        new ServiceWorkerProviderHost(
+            helper_->mock_render_process_id(), MSG_ROUTING_NONE,
+            kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
+            ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED,
+            context()->AsWeakPtr(), nullptr));
+    provider_host_ = host->AsWeakPtr();
+    context()->RemoveProviderHost(host->process_id(), host->provider_id());
+    context()->AddProviderHost(std::move(host));
+
+    scoped_refptr<ServiceWorkerRegistration> registration =
+        new ServiceWorkerRegistration(GURL("https://host/scope"), 1L,
+                                      context()->AsWeakPtr());
+    scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
+        registration.get(), GURL("https://host/script.js"), 1L,
+        context()->AsWeakPtr());
+
+    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);
+    version->SetStatus(ServiceWorkerVersion::ACTIVATED);
+    registration->SetActiveVersion(version);
+    context()->storage()->StoreRegistration(
+        registration.get(), version.get(),
+        base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+    base::RunLoop().RunUntilIdle();
+
+    provider_host_->running_hosted_version_ = version;
+  }
+
  private:
   class TestContentClient : public ContentClient {
    public:
     // ContentRendererClient methods
     OriginTrialPolicy* GetOriginTrialPolicy() override {
       return &origin_trial_policy_;
     }
 
    private:
     class TestOriginTrialPolicy : public OriginTrialPolicy {
      public:
       base::StringPiece GetPublicKey() const override {
         return base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
                                  arraysize(kTestPublicKey));
       }
       bool IsFeatureDisabled(base::StringPiece feature) const override {
         return false;
       }
     };
 
     TestOriginTrialPolicy origin_trial_policy_;
   };
 
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   TestContentClient test_content_client_;
+  TestContentBrowserClient test_content_browser_client_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   TestBrowserThreadBundle browser_thread_bundle_;
 
+  net::URLRequestContext url_request_context_;
+  MockURLRequestDelegate url_request_delegate_;
+  base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
+  storage::BlobStorageContext blob_storage_context_;
+  std::unique_ptr<net::URLRequest> request_;
+
   DISALLOW_COPY_AND_ASSIGN(ForeignFetchRequestHandlerTest);
 };
 
 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_NoToken) {
   EXPECT_TRUE(CheckOriginTrialToken(version()));
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_FALSE(CheckOriginTrialToken(version()));
 }
@@ skipping 46 matching lines @@
   const std::string kFeatureToken(
       "AgBgj4Zhwzn85LJw7rzh4ZFRFqp49+9Es2SrCwZdDcoqtqQEjbvui4SKLn6GqMpr4DynGfJh"
       "tIy9dpOuK8PVTwkAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0"
       "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMTAwMDAwMDAwMH0"
       "=");
   http_info->headers->AddHeader(kOriginTrial + kFeatureToken);
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_FALSE(CheckOriginTrialToken(version()));
 }
 
+TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_Success) {
+  EXPECT_TRUE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE,
+                                nullptr /* initiator */));
+}
+
+TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_WrongResourceType) {
+  EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_MAIN_FRAME,
+                                 nullptr /* initiator */));
+  EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SUB_FRAME,
+                                 nullptr /* initiator */));
+  // EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_WORKER, nullptr /*

[Marijn Kruisselbrink, 2016/12/02 00:15:02]

It surprised me a lot that ServiceWorkerUtils::IsMainResourceType does not
return true for dedicated workers or service workers. For whatever reason it
only considers shared workers to be main resources. Is that intentional? If so,
I guess I'll have to change my usage of it.

[falken, 2016/12/05 04:34:48]

I think the reason is that IsMainResourceType really means: "this provider
should have a controller". SW controlling a dedicated worker doesn't look fully
supported yet, we don't actually create a provider host with TYPE_WORKER ever
(https://codereview.chromium.org/717553003) or expose navigator.serviceWorker
(https://bugs.chromium.org/p/chromium/issues/detail?id=371690). It looks like
the SW does intercept fetches from the dedicated worker though, probably loads
from the dedicated worker are plumbed to its owning page.

Service workers are never controlled by another service worker by design.

So I think as of now we still expect InitializeHandler to return false for
non-shared worker, non-frame. Would certainly be better to have comments
somewhere explaining this.

[Marijn Kruisselbrink, 2016/12/05 20:46:52]

Hmm, okay... It also somewhat looks like this IsMainResourceType is just a copy
of the same method in AppCache code. Anyway, I most certainly never intended for
foreign fetch to be able to intercept main resources for workers, so for now
I've just changed the check in ForeignFetchRequestHandler to explicitly not
handle those resource types. But it seems like it would make sense to rename
IsMainResourceType to not imply that it returns true for all main resource
types...

+  // initiator */));
+  EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SHARED_WORKER,
+                                 nullptr /* initiator */));
+  // EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SERVICE_WORKER,
+  // nullptr /* initiator */));
+}
+
+TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_SameOriginRequest) {
+  EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE,
+                                 kValidUrl /* initiator */));
+}
+
+TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_NoRegisteredHandlers) {
+  EXPECT_FALSE(InitializeHandler("https://invalid.example.com/foo",
+                                 RESOURCE_TYPE_IMAGE, nullptr /* initiator */));
+}
+
+TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_TimeoutBehavior) {
+  ForeignFetchRequestHandler* handler =
+      InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE,
+                        nullptr /* initiator */);
+  ASSERT_TRUE(handler);
+
+  EXPECT_EQ(base::nullopt, timeout_for_request(handler));
+
+  CreateServiceWorkerTypeProviderHost();
+  ServiceWorkerVersion* version = provider_host()->running_hosted_version();
+
+  // Set mock clock on version to check timeout behavior.
+  base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock();
+  tick_clock->SetNowTicks(base::TimeTicks::Now());
+  version->SetTickClockForTesting(base::WrapUnique(tick_clock));
+
+  // Make sure worker has a non-zero timeout.
+  version->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
+                       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+  base::RunLoop().RunUntilIdle();
+  version->StartRequestWithCustomTimeout(
+      ServiceWorkerMetrics::EventType::ACTIVATE,
+      base::Bind(&ServiceWorkerUtils::NoOpStatusCallback),
+      base::TimeDelta::FromSeconds(10), ServiceWorkerVersion::KILL_ON_TIMEOUT);
+
+  // Advance clock by a couple seconds.
+  tick_clock->Advance(base::TimeDelta::FromSeconds(4));
+  base::TimeDelta remaining_time = version->remaining_timeout();
+  EXPECT_EQ(base::TimeDelta::FromSeconds(6), remaining_time);
+
+  // Make sure new request only gets remaining timeout.
+  handler = InitializeHandler("https://valid.example.com/foo",
+                              RESOURCE_TYPE_IMAGE, nullptr /* initiator */);
+  ASSERT_TRUE(handler);
+  EXPECT_EQ(remaining_time, timeout_for_request(handler));
+}
+
 }  // namespace content