BackgroundSyncManager tracks client registrations

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 153 matching lines @@
   *body = std::string(data->items()[0]->bytes(), data->items()[0]->length());
 }
 
 void ExpectResultAndRun(bool expected,
                         const base::Closure& continuation,
                         bool actual) {
   EXPECT_EQ(expected, actual);
   continuation.Run();
 }
 
-SyncRegistrationPtr CreateOneShotSyncRegistration(const std::string& tag) {
-  SyncRegistrationPtr registration = SyncRegistration::New();
-  registration->tag = tag;
-  return registration.Pass();
-}
-
 class WorkerActivatedObserver
     : public ServiceWorkerContextObserver,
       public base::RefCountedThreadSafe<WorkerActivatedObserver> {
  public:
   explicit WorkerActivatedObserver(ServiceWorkerContextWrapper* context)
       : context_(context) {}
   void Init() {
     RunOnIOThread(base::Bind(&WorkerActivatedObserver::InitOnIOThread, this));
   }
   // ServiceWorkerContextObserver overrides.
@@ skipping 343 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) {
-    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 199 matching lines @@
         CreateResponseReceiver(
             BrowserThread::UI, done, blob_context_.get(), result));
   }
 
   void StopOnIOThread(const base::Closure& done,
                       ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(version_.get());
     version_->StopWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
-  void SyncEventOnIOThread(const base::Closure& done,
-                           ServiceWorkerStatusCode* result) {
-    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-    version_->DispatchSyncEvent(
-        CreateOneShotSyncRegistration(""),
-        CreateReceiver(BrowserThread::UI, done, result));
-  }
-
  protected:
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   scoped_refptr<ChromeBlobStorageContext> blob_context_;
 };
 
 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 298 matching lines @@
             console_listener.messages()[0].find(expected1));
   ASSERT_EQ(0u, console_listener.messages()[1].find(expected2));
   version_->embedded_worker()->RemoveListener(&console_listener);
 
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(0, response.status_code);
 
   ASSERT_FALSE(blob_data_handle);
 }
 
-IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, SyncEventHandled) {
-  RunOnIOThread(base::Bind(
-      &self::SetUpRegistrationOnIOThread, this, "/service_worker/sync.js"));
-  ServiceWorkerFetchEventResult result;
-  ServiceWorkerResponse response;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
-  // Should 404 before sync event.
-  FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
-  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);
-
-  // 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, base::string16(1, '|'),
-                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-
-  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);
-}
-
-// https://crbug.com/504202
-#if defined(THREAD_SANITIZER)
-#define MAYBE_SyncEventWaitUntil_Rejected DISABLED_SyncEventWaitUntil_Rejected
-#else
-#define MAYBE_SyncEventWaitUntil_Rejected SyncEventWaitUntil_Rejected
-#endif
-IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
-                       MAYBE_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