Allow ServiceWorker events to have custom durations

content/browser/service_worker/service_worker_version_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/basictypes.h"
 #include "base/run_loop.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.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/background_sync_service.mojom.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // IPC messages for testing ---------------------------------------------------
 
 #define IPC_MESSAGE_IMPL
 #include "ipc/ipc_message_macros.h"
 
 #define IPC_MESSAGE_START TestMsgStart
 
 IPC_MESSAGE_CONTROL0(TestMsg_Message)
@@ skipping 34 matching lines @@
 
  private:
   void OnMessage() {
     // Do nothing.
   }
 
   int current_embedded_worker_id_;
   DISALLOW_COPY_AND_ASSIGN(MessageReceiver);
 };
 
+class MockBackgroundSyncServiceClient : public BackgroundSyncServiceClient {
+ public:
+  MockBackgroundSyncServiceClient(
+      mojo::InterfaceRequest<BackgroundSyncServiceClient> request)
+      : binding_(this, request.Pass()) {}
+
+ private:
+  // BackgroundSyncServiceClient overrides
+  void Sync(int64_t handle_id,
+            content::BackgroundSyncEventLastChance last_chance,
+            const SyncCallback& callback) override {
+    // Wait forever instead of calling the callback.
+  }
+
+  mojo::StrongBinding<BackgroundSyncServiceClient> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockBackgroundSyncServiceClient);
+};
+
 void VerifyCalled(bool* called) {
   *called = true;
 }
 
 void ObserveStatusChanges(ServiceWorkerVersion* version,
                           std::vector<ServiceWorkerVersion::Status>* statuses) {
   statuses->push_back(version->status());
   version->RegisterStatusChangeCallback(
       base::Bind(&ObserveStatusChanges, base::Unretained(version), statuses));
 }
 
 void ReceiveFetchResult(ServiceWorkerStatusCode* status,
                         ServiceWorkerStatusCode actual_status,
                         ServiceWorkerFetchEventResult actual_result,
                         const ServiceWorkerResponse& response) {
   *status = actual_status;
 }
 
+void ReceiveSyncStatus(ServiceWorkerStatusCode* status,
+                       ServiceWorkerStatusCode actual_status) {
+  *status = actual_status;
+}
+
 // A specialized listener class to receive test messages from a worker.
 class MessageReceiverFromWorker : public EmbeddedWorkerInstance::Listener {
  public:
   explicit MessageReceiverFromWorker(EmbeddedWorkerInstance* instance)
       : instance_(instance) {
     instance_->AddListener(this);
   }
   ~MessageReceiverFromWorker() override { instance_->RemoveListener(this); }
 
   void OnStarted() override { NOTREACHED(); }
@@ skipping 74 matching lines @@
         version_.get(),
         CreateReceiverOnCurrentThread(&status));
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(SERVICE_WORKER_OK, status);
 
     // Simulate adding one process to the pattern.
     helper_->SimulateAddProcessToPattern(pattern_,
                                          helper_->mock_render_process_id());
     ASSERT_TRUE(helper_->context()->process_manager()
         ->PatternHasProcessToRun(pattern_));
+
+    // Create a mock BackgroundSyncServiceClient
+    mojo::InterfaceRequest<BackgroundSyncServiceClient> service_request =

[Marijn Kruisselbrink, 2015/12/16 19:09:57]

FYI, after I clean up and land https://codereview.chromium.org/1264333002, there
will be a more clean way to have mock services for tests like this.

[jkarlin, 2015/12/16 20:44:27]

Nice!

+        mojo::GetProxy(&version_->background_sync_dispatcher_);
+    // The MocKBackgroundSyncServiceClient is bound to the client, and will be

[Marijn Kruisselbrink, 2015/12/16 19:09:57]

s/MocK/Mock/

[jkarlin, 2015/12/16 20:44:27]

Done.

+    // deleted when the client is deleted.
+    new MockBackgroundSyncServiceClient(service_request.Pass());
+    base::RunLoop().RunUntilIdle();
   }
 
   virtual scoped_ptr<MessageReceiver> GetMessageReceiver() {
     return make_scoped_ptr(new MessageReceiver());
   }
 
   void TearDown() override {
     version_ = 0;
     registration_ = 0;
     helper_.reset();
@@ skipping 553 matching lines @@
                                base::Bind(&base::DoNothing),
                                base::Bind(&ReceiveFetchResult, &status));
   base::RunLoop().RunUntilIdle();
 
   // Callback has not completed yet.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 
   // Simulate timeout.
   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
-  version_->SetAllRequestTimes(
-      base::TimeTicks::Now() -
-      base::TimeDelta::FromMinutes(
-          ServiceWorkerVersion::kRequestTimeoutMinutes + 1));
+  version_->SetAllRequestExpirations(base::TimeTicks::Now());
   version_->timeout_timer_.user_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status);
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 }
 
+TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) {
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
+  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
+
+  // Create a sync request that should expire Now().
+  version_->DispatchSyncEvent(0 /* sync handle id */,
+                              BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
+                              base::TimeTicks::Now(), /* expiration time */
+                              base::Bind(&ReceiveSyncStatus, &status));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(version_->timeout_timer_.IsRunning());
+  version_->timeout_timer_.user_task().Run();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status);
+  EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
+}
+
+TEST_F(ServiceWorkerWaitForeverInFetchTest, MixedRequestTimeouts) {
+  ServiceWorkerStatusCode sync_status =
+      SERVICE_WORKER_ERROR_NETWORK;  // dummy value
+  ServiceWorkerStatusCode fetch_status =
+      SERVICE_WORKER_ERROR_NETWORK;  // dummy value
+  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
+
+  // Create a fetch request that should expire sometime later.
+  version_->DispatchFetchEvent(ServiceWorkerFetchRequest(),
+                               base::Bind(&base::DoNothing),
+                               base::Bind(&ReceiveFetchResult, &fetch_status));
+  // Create a sync request that should expire Now().
+  version_->DispatchSyncEvent(0 /* sync handle id */,
+                              BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
+                              base::TimeTicks::Now(), /* expiration time */
+                              base::Bind(&ReceiveSyncStatus, &sync_status));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, sync_status);
+
+  // Verify the sync has timed out but not the fetch.
+  EXPECT_TRUE(version_->timeout_timer_.IsRunning());
+  version_->timeout_timer_.user_task().Run();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status);
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status);
+  EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
+
+  // Verify that the fetch times out later.
+  version_->SetAllRequestExpirations(base::TimeTicks::Now());
+  version_->timeout_timer_.user_task().Run();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status);
+  EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
+}
+
 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) {
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
   version_->StartWorker(
       CreateReceiverOnCurrentThread(&status));
   base::RunLoop().RunUntilIdle();
 
   // Callback has not completed yet.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 
@@ skipping 156 matching lines @@
   GURL valid_scope_2("http://www.example.com/test/subscope");
   version_->OnRegisterForeignFetchScopes(std::vector<GURL>(1, valid_scope_2));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, helper_->mock_render_process_host()->bad_msg_count());
   EXPECT_EQ(2u, version_->foreign_fetch_scopes_.size());
   EXPECT_EQ(valid_scope_1, version_->foreign_fetch_scopes_[0]);
   EXPECT_EQ(valid_scope_2, version_->foreign_fetch_scopes_[1]);
 }
 
 }  // namespace content