Reland of [Background Sync] Trigger Background Sync events when Chrome is backgrounded on Android

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/browser_test_utils.h"
@@ skipping 61 matching lines @@
     const scoped_refptr<BackgroundSyncContext> sync_context,
     const scoped_refptr<ServiceWorkerContextWrapper> sw_context,
     const std::string& tag,
     const GURL& url,
     const base::Callback<void(bool)>& callback) {
   sw_context->FindRegistrationForDocument(
       url, base::Bind(&OneShotPendingDidGetSWRegistration, sync_context, tag,
                       callback));
 }
 
+}  // namespace
+
 class BackgroundSyncBrowserTest : public ContentBrowserTest {
  public:
   BackgroundSyncBrowserTest() {}
   ~BackgroundSyncBrowserTest() override {}
 
   void SetUp() override {
-    NetworkChangeNotifier::SetTestNotificationsOnly(true);
-
-#if defined(OS_CHROMEOS)
-    // ChromeOS's NetworkChangeNotifier doesn't get created in
-    // content_browsertests, so make one now.
-    net::NetworkChangeNotifier::CreateMock();
-#endif
-
+    BackgroundSyncNetworkObserver::SetIgnoreNetworkChangeNotifierForTests(true);
     ContentBrowserTest::SetUp();
   }
 
   void SetIncognitoMode(bool incognito) {
     shell_ = incognito ? CreateOffTheRecordBrowser() : shell();
   }
 
+  BackgroundSyncContext* GetSyncContextFromShell(Shell* shell) {
+    StoragePartition* storage = BrowserContext::GetDefaultStoragePartition(
+        shell_->web_contents()->GetBrowserContext());
+    return storage->GetBackgroundSyncContext();
+  }
+
   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::SpawnedTestServer(
         net::SpawnedTestServer::TYPE_HTTPS,
         net::BaseTestServer::SSLOptions(
             net::BaseTestServer::SSLOptions::CERT_OK),
         base::FilePath(FILE_PATH_LITERAL("content/test/data/"))));
     ASSERT_TRUE(https_server_->Start());
 
+    SetIncognitoMode(false);
+
     SetOnline(true);
 
-    SetIncognitoMode(false);
-
     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);
   }
 
+  // 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);
 
   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();
   bool NotifyWhenDoneOneShot(const std::string& tag);
   bool NotifyWhenDoneImmediateOneShot(const std::string& expected_msg);
   bool StoreRegistrationOneShot(const std::string& tag);
 
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
 };
 
 void BackgroundSyncBrowserTest::SetOnline(bool online) {
-  if (online) {
-    NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
-        NetworkChangeNotifier::CONNECTION_WIFI);
-  } else {
-    NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
-        NetworkChangeNotifier::CONNECTION_NONE);
-  }
+  ASSERT_TRUE(shell_);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BackgroundSyncBrowserTest::SetOnlineOnIOThread,
+                 base::Unretained(this),
+                 base::Unretained(GetSyncContextFromShell(shell_)), 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->NotifyManagerIfNetworkChanged(
+        NetworkChangeNotifier::CONNECTION_WIFI);
+  } else {
+    network_observer->NotifyManagerIfNetworkChanged(
+        NetworkChangeNotifier::CONNECTION_NONE);
+  }
+}
+
 bool BackgroundSyncBrowserTest::OneShotPending(const std::string& tag) {
   bool is_pending;
   base::RunLoop run_loop;
 
   StoragePartition* storage = BrowserContext::GetDefaultStoragePartition(
       shell_->web_contents()->GetBrowserContext());
   BackgroundSyncContext* sync_context = storage->GetBackgroundSyncContext();
   ServiceWorkerContextWrapper* service_worker_context =
       static_cast<ServiceWorkerContextWrapper*>(
           storage->GetServiceWorkerContext());
@@ skipping 308 matching lines @@
   SetOnline(true);
   EXPECT_TRUE(RegisterOneShot("delay"));
   EXPECT_FALSE(OneShotPending("delay"));
   EXPECT_TRUE(StoreRegistrationOneShot("delay"));
 
   EXPECT_TRUE(RejectDelayedOneShot());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
   EXPECT_TRUE(NotifyWhenDoneImmediateOneShot("ok - delay result: false"));
 }
 
-}  // namespace
-
 }  // namespace content