BackgroundSyncManager tracks client registrations

content/browser/background_sync/background_sync_browsertest.cc

 // Copyright 2015 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 <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "content/browser/background_sync/background_sync_manager.h"
+#include "content/browser/background_sync/background_sync_registration_handle.h"
 #include "content/browser/background_sync/background_sync_status.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/public/browser/background_sync_context.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
@@ skipping 29 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     bool* result_out,
     bool result) {
   *result_out = result;
   task_runner->PostTask(FROM_HERE, quit);
 }
 
 void OneShotPendingDidGetSyncRegistration(
     const base::Callback<void(bool)>& callback,
     BackgroundSyncStatus error_type,
-    const BackgroundSyncRegistration& registration) {
+    scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
   ASSERT_EQ(BACKGROUND_SYNC_STATUS_OK, error_type);
-  callback.Run(registration.sync_state() == SYNC_STATE_PENDING);
+  callback.Run(registration_handle->sync_state() == SYNC_STATE_PENDING);
 }
 
 void OneShotPendingDidGetSWRegistration(
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const std::string& tag,
     const base::Callback<void(bool)>& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   ASSERT_EQ(SERVICE_WORKER_OK, status);
   int64 service_worker_id = registration->id();
@@ skipping 72 matching lines @@
 
   void SetOnline(bool online);
 
   // Returns true if the one-shot sync with tag is currently pending. Fails
   // (assertion failure) if the tag isn't registered.
   bool OneShotPending(const std::string& tag);
 
   bool PopConsole(const std::string& expected_msg);
   bool RegisterServiceWorker();
   bool RegisterOneShot(const std::string& tag);
+  bool UnregisterOneShot(const std::string& tag);
+  bool UnregisterOneShotTwice(const std::string& tag);
   bool GetRegistrationOneShot(const std::string& tag);
   bool GetRegistrationsOneShot(const std::vector<std::string>& expected_tags);
   bool CompleteDelayedOneShot();
   bool RejectDelayedOneShot();
 
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
@@ skipping 48 matching lines @@
   return script_result == BuildExpectedResult("service worker", "registered");
 }
 
 bool BackgroundSyncBrowserTest::RegisterOneShot(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(
       RunScript(BuildScriptString("registerOneShot", tag), &script_result));
   return script_result == BuildExpectedResult(tag, "registered");
 }
 
+bool BackgroundSyncBrowserTest::UnregisterOneShot(const std::string& tag) {
+  std::string script_result;
+  EXPECT_TRUE(
+      RunScript(BuildScriptString("unregisterOneShot", tag), &script_result));
+  return script_result == BuildExpectedResult(tag, "unregistered");
+}
+
+bool BackgroundSyncBrowserTest::UnregisterOneShotTwice(const std::string& tag) {
+  std::string script_result;
+  EXPECT_TRUE(RunScript(BuildScriptString("unregisterOneShotTwice", tag),
+                        &script_result));
+  return script_result ==
+         BuildExpectedResult(tag, "failed to unregister twice");
+}
+
 bool BackgroundSyncBrowserTest::GetRegistrationOneShot(const std::string& tag) {
   std::string script_result;
   EXPECT_TRUE(RunScript(BuildScriptString("getRegistrationOneShot", tag),
                         &script_result));
   return script_result == BuildExpectedResult(tag, "found");
 }
 
 bool BackgroundSyncBrowserTest::GetRegistrationsOneShot(
     const std::vector<std::string>& expected_tags) {
   std::string script_result;
@@ skipping 131 matching lines @@
   SetOnline(false);
   registered_tags.push_back("foo");
   registered_tags.push_back("bar");
 
   for (const std::string& tag : registered_tags)
     EXPECT_TRUE(RegisterOneShot(tag));
 
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 }
 
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, Unregister) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(false);
+  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(UnregisterOneShot("foo"));
+  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, UnregisterTwice) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  SetOnline(false);
+  EXPECT_TRUE(RegisterOneShot("foo"));
+  EXPECT_TRUE(UnregisterOneShotTwice("foo"));
+  EXPECT_FALSE(GetRegistrationOneShot("foo"));
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, UnregisterMidSync) {
+  EXPECT_TRUE(RegisterServiceWorker());
+  EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
+
+  EXPECT_TRUE(RegisterOneShot("unregister"));
+  EXPECT_TRUE(PopConsole("ok - unregister completed"));
+}
+
 }  // namespace
 
 }  // namespace content