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()) {}
+
+  void RunCallback() {
+    EXPECT_FALSE(callback_.is_null());
+    callback_.Run(SERVICE_WORKER_EVENT_STATUS_ABORTED);
+  }
+
+ private:
+  // BackgroundSyncServiceClient overrides
+  void Sync(int64_t handle_id,
+            content::BackgroundSyncEventLastChance last_chance,
+            const SyncCallback& callback) override {
+    EXPECT_TRUE(callback_.is_null());
+    callback_ = callback;
+  }
+
+  SyncCallback 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 39 matching lines @@
   struct RunningStateListener : public ServiceWorkerVersion::Listener {
     RunningStateListener() : last_status(ServiceWorkerVersion::STOPPED) {}
     ~RunningStateListener() override {}
     void OnRunningStateChanged(ServiceWorkerVersion* version) override {
       last_status = version->running_status();
     }
     ServiceWorkerVersion::RunningStatus last_status;
   };
 
   ServiceWorkerVersionTest()
-      : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
+      : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
+        mock_background_sync_dispatcher_(nullptr) {}
 
   void SetUp() override {
     helper_ = GetMessageReceiver();
 
     pattern_ = GURL("http://www.example.com/test/");
     registration_ = new ServiceWorkerRegistration(
         pattern_,
         1L,
         helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
@@ skipping 14 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

[falken, 2015/12/18 01:28:48]

apologetic nit: add period to sentence

[jkarlin, 2015/12/18 12:28:30]

Done.

+    mojo::InterfaceRequest<BackgroundSyncServiceClient> service_request =
+        mojo::GetProxy(&version_->background_sync_dispatcher_);
+    // The MockBackgroundSyncServiceClient is bound to the client, and will be
+    // deleted when the client is deleted.
+    mock_background_sync_dispatcher_ =
+        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();
   }
 
   TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<MessageReceiver> helper_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
+  MockBackgroundSyncServiceClient* mock_background_sync_dispatcher_;
   GURL pattern_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest);
 };
 
 class MessageReceiverDisallowStart : public MessageReceiver {
  public:
   MessageReceiverDisallowStart()
       : MessageReceiver() {}
@@ skipping 537 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::TimeDelta(), /* max duration */
+                              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);
+}
+
+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::TimeDelta(), /* max duration */
+                              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);
+
+  // Background sync timeouts don't stop the service worker.
+  EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
+
+  // Gracefully handle the sync event finishing after the timeout.
+  mock_background_sync_dispatcher_->RunCallback();
+  base::RunLoop().RunUntilIdle();
+
+  // 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);
+
+  // Other timeouts do stop the service worker.
+  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