BackgroundSync sync events need to be ExtendableEvents, content browser tests

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 "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 523 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);
   }
 
+  base::string16 RunSyncTestWithConsoleOutput(
+      const std::string& worker_url,
+      ServiceWorkerStatusCode expected_status) {
+    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+    command_line->AppendSwitch(switches::kEnableServiceWorkerSync);
+    RunOnIOThread(
+        base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
+    return SyncOnRegisteredWorkerWithConsoleOutput(expected_status);
+  }
+
+  void SyncOnRegisteredWorker(ServiceWorkerStatusCode expected_status) {
+    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(expected_status, status);
+  }
+
+  base::string16 SyncOnRegisteredWorkerWithConsoleOutput(
+      ServiceWorkerStatusCode expected_status) {
+    ConsoleListener console_listener;
+    version_->embedded_worker()->AddListener(&console_listener);
+
+    SyncOnRegisteredWorker(expected_status);
+
+    console_listener.WaitForConsoleMessages(1);
+    base::string16 console_output = console_listener.messages()[0];
+    version_->embedded_worker()->RemoveListener(&console_listener);
+    return console_output;
+  }
+
   void FetchOnRegisteredWorker(
       ServiceWorkerFetchEventResult* result,
       ServiceWorkerResponse* response,
       scoped_ptr<storage::BlobDataHandle>* blob_data_handle) {
     blob_context_ = ChromeBlobStorageContext::GetFor(
         shell()->web_contents()->GetBrowserContext());
     bool prepare_result = false;
     FetchResult fetch_result;
     fetch_result.status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop fetch_run_loop;
@@ skipping 598 matching lines @@
                                      sync_run_loop.QuitClosure(),
                                      &status));
   sync_run_loop.Run();
   ASSERT_EQ(SERVICE_WORKER_OK, status);
 
   // Should 200 after sync event.
   FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   EXPECT_EQ(200, response.status_code);
 }
 
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, SyncEventInterface) {
+  // Verify that the fired sync event has the correct interface.
+  // The js event handler will console.log the event properties.
+  base::string16 console_output = RunSyncTestWithConsoleOutput(
+      "/background_sync/sync_event_interface.js", SERVICE_WORKER_OK);
+
+  EXPECT_FALSE(console_output.empty());
+
+  // Console output is a pipe-delimited string, as:
+  // <event prototype>|<typeof waitUntil>
+  std::vector<base::string16> event_properties;
+  base::SplitString(console_output, '|', &event_properties);
+
+  const base::string16::size_type num_properties = 2;
+  const base::string16 event_type = base::ASCIIToUTF16("SyncEvent");
+  const base::string16 wait_until_type = base::ASCIIToUTF16("function");
+  EXPECT_EQ(num_properties, event_properties.size());
+  EXPECT_EQ(event_type, event_properties[0]);
+  EXPECT_EQ(wait_until_type, event_properties[1]);
+}
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
+                       SyncEventWaitUntil_Fulfilled) {
+  base::string16 console_output = RunSyncTestWithConsoleOutput(
+      "/background_sync/sync_event_fulfilled.js", SERVICE_WORKER_OK);
+
+  // Verify that the event.waitUntil function resolved the promise.  If so,
+  // the js event handler will console.log the expected output.
+  const base::string16 expected = base::ASCIIToUTF16("Fulfilling onsync event");
+  EXPECT_EQ(expected, console_output);
+}
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
+                       SyncEventWaitUntil_Rejected) {
+  base::string16 console_output = RunSyncTestWithConsoleOutput(
+      "/background_sync/sync_event_rejected.js",
+      SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED);
+
+  // Verify that the event.waitUntil function rejected the promise.  If so,
+  // the js event handler will console.log the expected output.
+  const base::string16 expected = base::ASCIIToUTF16("Rejecting onsync event");
+  EXPECT_EQ(expected, console_output);
+}
+
 IN_PROC_BROWSER_TEST_F(ServiceWorkerBrowserTest, Reload) {
   const char kPageUrl[] = "/service_worker/reload.html";
   const char kWorkerUrl[] = "/service_worker/fetch_event_reload.js";
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
   observer->Init();
   public_context()->RegisterServiceWorker(
       embedded_test_server()->GetURL(kPageUrl),
       embedded_test_server()->GetURL(kWorkerUrl),
       base::Bind(&ExpectResultAndRun, true, base::Bind(&base::DoNothing)));
@@ skipping 320 matching lines @@
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
   // Restart the worker.
   StartWorker(SERVICE_WORKER_OK);
   // Stop the worker.
   StopWorker(SERVICE_WORKER_OK);
 }
 
 }  // namespace content