Browser side of ServiceWorker requestSyncEvents() function

content/browser/service_worker/service_worker_browsertest.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/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 258 matching lines @@
     base::RunLoop run_loop;
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(
             &self::ActivateOnIOThread, this, run_loop.QuitClosure(), &status));
     run_loop.Run();
     ASSERT_EQ(expected_status, status);
   }
 
-  void FetchOnRegisteredWorker(ServiceWorkerFetchEventResult* result,
+  bool FetchOnRegisteredWorker(ServiceWorkerFetchEventResult* result,
                                ServiceWorkerResponse* response) {
     FetchResult fetch_result;
     fetch_result.status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop fetch_run_loop;
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
                             base::Bind(&self::FetchOnIOThread,
                                        this,
                                        fetch_run_loop.QuitClosure(),
                                        &fetch_result));
     fetch_run_loop.Run();
     *result = fetch_result.result;
     *response = fetch_result.response;
-    ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status);
+    return fetch_result.status == SERVICE_WORKER_OK;
   }
 
   void FetchTestHelper(const std::string& worker_url,
                        ServiceWorkerFetchEventResult* result,
                        ServiceWorkerResponse* response) {
     RunOnIOThread(
         base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
 
     FetchOnRegisteredWorker(result, response);
   }
@@ skipping 49 matching lines @@
     version_->StopWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void SyncEventOnIOThread(const base::Closure& done,
                            ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->DispatchSyncEvent(
         CreateReceiver(BrowserThread::UI, done, result));
   }
 
+  bool FireSyncEvent() {
+    // Run the sync event.
+    ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+    base::RunLoop sync_run_loop;
+    BrowserThread::PostTask(BrowserThread::IO,
+                            FROM_HERE,
+                            base::Bind(&self::SyncEventOnIOThread,
+                                       this,
+                                       sync_run_loop.QuitClosure(),
+                                       &status));
+    sync_run_loop.Run();
+    return status == SERVICE_WORKER_OK;
+  }
+
  protected:
   int64 next_registration_id_;
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
 };
 
 IN_PROC_BROWSER_TEST_F(EmbeddedWorkerBrowserTest, StartAndStop) {
   // Start a worker and wait until OnStarted() is called.
   base::RunLoop start_run_loop;
   done_closure_ = start_run_loop.QuitClosure();
@@ skipping 101 matching lines @@
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, result);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Rejected) {
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
   FetchTestHelper("/service_worker/fetch_event_error.js", &result, &response);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, result);
 }
 
-IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, SyncEventHandled) {
-  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
-                           "/service_worker/sync.js"));
+// Show that sync works and that the requestSyncEvents function appropriately
+// controls sync events.
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
+                       SyncEventAndRequestFunction) {
+  RunOnIOThread(base::Bind(
+      &self::SetUpRegistrationOnIOThread, this, "/service_worker/sync.js"));
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
 
-  // Should 404 before sync event.
-  FetchOnRegisteredWorker(&result, &response);
+  // Fetch will return 200 if the sync event was fired, else 404.
+  // Each fetch event will cause requestSyncEvent to be called with
+  // different parameters, as described in the comments below.
+  // The simpler ways to do this (e.g., putting the command in the URL)
+  // don't work because at the time of writing SWs don't actually pass
+  // the URL to the fetch event.
+
+  EXPECT_FALSE(FireSyncEvent());  // Should not fire, next response 404.
+  EXPECT_TRUE(FetchOnRegisteredWorker(&result,
+                                      &response));  // Calls requestSyncEvents()
   EXPECT_EQ(404, response.status_code);
 
-  // Run the sync event.
-  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
-  base::RunLoop sync_run_loop;
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&self::SyncEventOnIOThread, this,
-                                     sync_run_loop.QuitClosure(),
-                                     &status));
-  sync_run_loop.Run();
-  ASSERT_EQ(SERVICE_WORKER_OK, status);
+  EXPECT_FALSE(FireSyncEvent());  // Should not fire, next response 404.
+  EXPECT_TRUE(
+      FetchOnRegisteredWorker(&result,
+                              &response));  // Calls requestSyncEvents(true)
+  EXPECT_EQ(404, response.status_code);
 
-  // Should 200 after sync event.
-  FetchOnRegisteredWorker(&result, &response);
+  EXPECT_TRUE(FireSyncEvent());  // Should fire, next response 200.
+  EXPECT_TRUE(FetchOnRegisteredWorker(
+      &result, &response));  // Calls requestSyncEvents(false)
   EXPECT_EQ(200, response.status_code);
+
+  EXPECT_FALSE(FireSyncEvent());  // Should fire, next response 404.
+  EXPECT_TRUE(FetchOnRegisteredWorker(&result, &response));
+  EXPECT_EQ(404, response.status_code);
 }
 
 class ServiceWorkerBlackBoxBrowserTest : public ServiceWorkerBrowserTest {
  public:
   typedef ServiceWorkerBlackBoxBrowserTest self;
 
   static void ExpectResultAndRun(bool expected,
                                  const base::Closure& continuation,
                                  bool actual) {
     EXPECT_EQ(expected, actual);
@@ skipping 75 matching lines @@
         base::Bind(&ServiceWorkerBlackBoxBrowserTest::FindRegistrationOnIO,
                    this,
                    embedded_test_server()->GetURL("/service_worker/empty.html"),
                    &status,
                    &script_url));
     EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, status);
   }
 }
 
 }  // namespace content