Extension SW - add test for ServiceWorkerRegistration.sync.

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_network_observer.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/background_sync_test_util.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "net/base/network_change_notifier.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::NetworkChangeNotifier;
@@ skipping 69 matching lines @@
 }
 
 }  // namespace
 
 class BackgroundSyncBrowserTest : public ContentBrowserTest {
  public:
   BackgroundSyncBrowserTest() {}
   ~BackgroundSyncBrowserTest() override {}
 
   void SetUp() override {
-    BackgroundSyncNetworkObserver::SetIgnoreNetworkChangeNotifierForTests(true);
+    background_sync_test_util::SetIgnoreNetworkChangeNotifier(true);
+
     ContentBrowserTest::SetUp();
   }
 
   void SetIncognitoMode(bool incognito) {
     shell_ = incognito ? CreateOffTheRecordBrowser() : shell();
   }
 
   StoragePartition* GetStorage() {
     WebContents* web_contents = shell_->web_contents();
     return BrowserContext::GetStoragePartition(
         web_contents->GetBrowserContext(), web_contents->GetSiteInstance());
   }
 
   BackgroundSyncContext* GetSyncContext() {
     return GetStorage()->GetBackgroundSyncContext();
   }
 
+  WebContents* web_contents() { return shell_->web_contents(); }
+
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // TODO(jkarlin): Remove this once background sync is no longer
     // experimental.
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
   }
 
   void SetUpOnMainThread() override {
     https_server_.reset(
         new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
     https_server_->ServeFilesFromSourceDirectory("content/test/data");
     ASSERT_TRUE(https_server_->Start());
 
     SetIncognitoMode(false);
     SetMaxSyncAttempts(1);
-    SetOnline(true);
+    background_sync_test_util::SetOnline(web_contents(), true);
     ASSERT_TRUE(LoadTestPage(kDefaultTestURL));
 
     ContentBrowserTest::SetUpOnMainThread();
   }
 
   void TearDownOnMainThread() override { https_server_.reset(); }
 
   bool LoadTestPage(const std::string& path) {
     return NavigateToURL(shell_, https_server_->GetURL(path));
   }
 
   bool RunScript(const std::string& script, std::string* result) {
-    return content::ExecuteScriptAndExtractString(shell_->web_contents(),
-                                                  script, result);
+    return content::ExecuteScriptAndExtractString(web_contents(), script,
+                                                  result);
   }
 
-  // This runs asynchronously on the IO thread, but we don't need to wait for it
-  // to complete before running a background sync operation, since those also
-  // run on the IO thread.
-  void SetOnline(bool online);
-  void SetOnlineOnIOThread(
-      const scoped_refptr<BackgroundSyncContext>& sync_context,
-      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);
 
   // Sets the BackgroundSyncManager's max sync attempts per registration.
   void SetMaxSyncAttempts(int max_sync_attempts);
 
   void ClearStoragePartitionData();
 
   std::string PopConsoleString();
@@ skipping 11 matching lines @@
   bool CompleteDelayedOneShot();
   bool RejectDelayedOneShot();
 
  private:
   scoped_ptr<net::EmbeddedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
 };
 
-void BackgroundSyncBrowserTest::SetOnline(bool online) {
-  ASSERT_TRUE(shell_);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&BackgroundSyncBrowserTest::SetOnlineOnIOThread,
-                 base::Unretained(this), base::Unretained(GetSyncContext()),
-                 online));
-  base::RunLoop().RunUntilIdle();
-}
-
-void BackgroundSyncBrowserTest::SetOnlineOnIOThread(
-    const scoped_refptr<BackgroundSyncContext>& sync_context,
-    bool online) {
-  BackgroundSyncManager* sync_manager = sync_context->background_sync_manager();
-  BackgroundSyncNetworkObserver* network_observer =
-      sync_manager->GetNetworkObserverForTesting();
-  if (online) {
-    network_observer->NotifyManagerIfNetworkChangedForTesting(
-        NetworkChangeNotifier::CONNECTION_WIFI);
-  } else {
-    network_observer->NotifyManagerIfNetworkChangedForTesting(
-        NetworkChangeNotifier::CONNECTION_NONE);
-  }
-}
-
 bool BackgroundSyncBrowserTest::OneShotPending(const std::string& tag) {
   bool is_pending;
   base::RunLoop run_loop;
 
   StoragePartition* storage = GetStorage();
   BackgroundSyncContext* sync_context = storage->GetBackgroundSyncContext();
   ServiceWorkerContextWrapper* service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           storage->GetServiceWorkerContext());
 
@@ skipping 162 matching lines @@
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
   EXPECT_TRUE(PopConsole("foo_sw fired"));
   EXPECT_FALSE(GetRegistrationOneShot("foo_sw"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, OneShotDelaysForNetwork) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   // Prevent firing by going offline.
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
   EXPECT_TRUE(RegisterOneShot("foo"));
   EXPECT_TRUE(GetRegistrationOneShot("foo"));
   EXPECT_TRUE(OneShotPending("foo"));
 
   // Resume firing by going online.
-  SetOnline(true);
+  background_sync_test_util::SetOnline(web_contents(), true);
   EXPECT_TRUE(PopConsole("foo fired"));
   EXPECT_FALSE(GetRegistrationOneShot("foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, WaitUntil) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  SetOnline(true);
+  background_sync_test_util::SetOnline(web_contents(), true);
   EXPECT_TRUE(RegisterOneShot("delay"));
 
   // Verify that it is firing.
   EXPECT_TRUE(GetRegistrationOneShot("delay"));
   EXPECT_FALSE(OneShotPending("delay"));
 
   // Complete the task.
   EXPECT_TRUE(CompleteDelayedOneShot());
   EXPECT_TRUE(PopConsole("ok - delay completed"));
 
   // Verify that it finished firing.
   EXPECT_FALSE(GetRegistrationOneShot("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, WaitUntilReject) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  SetOnline(true);
+  background_sync_test_util::SetOnline(web_contents(), true);
   EXPECT_TRUE(RegisterOneShot("delay"));
 
   // Verify that it is firing.
   EXPECT_TRUE(GetRegistrationOneShot("delay"));
   EXPECT_FALSE(OneShotPending("delay"));
 
   // Complete the task.
   EXPECT_TRUE(RejectDelayedOneShot());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
   EXPECT_FALSE(GetRegistrationOneShot("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, Incognito) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
   EXPECT_TRUE(RegisterOneShot("normal"));
   EXPECT_TRUE(OneShotPending("normal"));
 
   // Go incognito and verify that incognito doesn't see the registration.
   SetIncognitoMode(true);
 
   // Tell the new network observer that we're offline (it initializes from
   // NetworkChangeNotifier::GetCurrentConnectionType() which is not mocked out
   // in this test).
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
 
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   EXPECT_FALSE(GetRegistrationOneShot("normal"));
 
   EXPECT_TRUE(RegisterOneShot("incognito"));
   EXPECT_TRUE(OneShotPending("incognito"));
 
   // Switch back and make sure the registration is still there.
   SetIncognitoMode(false);
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Should be controlled.
 
   EXPECT_TRUE(GetRegistrationOneShot("normal"));
   EXPECT_FALSE(GetRegistrationOneShot("incognito"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, GetRegistrations) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), 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));
 }
 
 // Verify that GetRegistrations works in a service worker
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        GetRegistrationsFromServiceWorker) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
   registered_tags.push_back("foo_sw");
   registered_tags.push_back("bar_sw");
 
   for (const std::string& tag : registered_tags) {
     EXPECT_TRUE(RegisterOneShotFromServiceWorker(tag));
     EXPECT_TRUE(PopConsole(BuildExpectedResult(tag, "registered in SW")));
   }
 
   EXPECT_TRUE(GetRegistrationsOneShotFromServiceWorker(registered_tags));
 }
 
 // Verify that GetRegistration works in a service worker
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        GetRegistrationFromServiceWorker) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
 
   EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
   EXPECT_TRUE(GetRegistrationOneShotFromServiceWorker("foo_sw"));
 }
 
 // Verify that a background sync registration is deleted when site data is
 // cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   // Prevent firing by going offline.
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
   EXPECT_TRUE(RegisterOneShot("foo"));
   EXPECT_TRUE(GetRegistrationOneShot("foo"));
   EXPECT_TRUE(OneShotPending("foo"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   EXPECT_FALSE(GetRegistrationOneShot("foo"));
 }
 
 // Verify that a background sync registration, from a service worker, is deleted
 // when site data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationFromSWDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), false);
 
   EXPECT_TRUE(RegisterOneShotFromServiceWorker("foo_sw"));
   EXPECT_TRUE(PopConsole("ok - foo_sw registered in SW"));
   EXPECT_TRUE(GetRegistrationOneShotFromServiceWorker("foo_sw"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   EXPECT_FALSE(GetRegistrationOneShotFromServiceWorker("foo"));
 }
 
 // Verify that multiple background sync registrations are deleted when site
 // data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        SyncRegistrationsDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   std::vector<std::string> registered_tags;
   EXPECT_TRUE(GetRegistrationsOneShot(registered_tags));
 
-  SetOnline(false);
+  background_sync_test_util::SetOnline(web_contents(), 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));
 
   for (const std::string& tag : registered_tags)
     EXPECT_TRUE(OneShotPending(tag));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   for (const std::string& tag : registered_tags)
     EXPECT_FALSE(GetRegistrationOneShot(tag));
 }
 
 // Verify that a sync event that is currently firing is deleted when site
 // data is cleared.
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
                        FiringSyncEventDeletedWhenClearingSiteData) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
-  SetOnline(true);
+  background_sync_test_util::SetOnline(web_contents(), true);
   EXPECT_TRUE(RegisterOneShot("delay"));
 
   // Verify that it is firing.
   EXPECT_TRUE(GetRegistrationOneShot("delay"));
   EXPECT_FALSE(OneShotPending("delay"));
 
   // Simulate a user clearing site data (including Service Workers, crucially),
   // by clearing data from the storage partition.
   ClearStoragePartitionData();
 
   // Verify that it was deleted.
   EXPECT_FALSE(GetRegistrationOneShot("delay"));
 }
 
 IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, VerifyRetry) {
   EXPECT_TRUE(RegisterServiceWorker());
   EXPECT_TRUE(LoadTestPage(kDefaultTestURL));  // Control the page.
 
   SetMaxSyncAttempts(2);
 
   EXPECT_TRUE(RegisterOneShot("delay"));
   EXPECT_TRUE(RejectDelayedOneShot());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
 
   // Verify that the oneshot is still around and waiting to try again.
   EXPECT_TRUE(OneShotPending("delay"));
 }
 
 }  // namespace content