Reland of [Background Sync] Allow sync manager access from uncontrolled clients

content/browser/background_sync/background_sync_manager_unittest.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 "content/browser/background_sync/background_sync_manager.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
@@ skipping 356 matching lines @@
 
   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
   }
 
   bool RegisterWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncRegistrationOptions& options) {
     bool was_called = false;
     background_sync_manager_->Register(
-        sw_registration_id, options,
+        sw_registration_id, options, true /* requested_from_service_worker */,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
+    EXPECT_TRUE(was_called);
+    return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
+  }
+
+  bool RegisterFromDocumentWithServiceWorkerId(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistrationOptions& options) {
+    bool was_called = false;
+    background_sync_manager_->Register(
+        sw_registration_id, options, false /* requested_from_service_worker */,
+        base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
+                   base::Unretained(this), &was_called));
+    base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   bool Unregister(const BackgroundSyncRegistration& sync_registration) {
     return UnregisterWithServiceWorkerId(sw_registration_id_1_,
                                          sync_registration);
   }
 
   bool UnregisterWithServiceWorkerId(
@@ skipping 384 matching lines @@
   // the operations complete sequentially.
   SetupDelayedBackgroundSyncManager();
 
   const int64 kExpectedInitialId = BackgroundSyncRegistration::kInitialId;
 
   bool register_called = false;
   bool unregister_called = false;
   bool get_registration_called = false;
   test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_options_1_,
+      true /* requested_from_service_worker */,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &register_called));
   test_background_sync_manager_->Unregister(
       sw_registration_id_1_, sync_options_1_.tag, sync_options_1_.periodicity,
       kExpectedInitialId,
       base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                  base::Unretained(this), &unregister_called));
   test_background_sync_manager_->GetRegistration(
       sw_registration_id_1_, sync_options_1_.tag, sync_options_1_.periodicity,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
@@ skipping 37 matching lines @@
 }
 
 TEST_F(BackgroundSyncManagerTest,
        UnregisterServiceWorkerDuringSyncRegistration) {
   EXPECT_TRUE(Register(sync_options_1_));
 
   test_background_sync_manager_->set_delay_backend(true);
   bool callback_called = false;
   test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_options_2_,
+      true /* requested_from_service_worker */,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &callback_called));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_called);
   UnregisterServiceWorker(sw_registration_id_1_);
 
   test_background_sync_manager_->Continue();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_called);
@@ skipping 410 matching lines @@
   RemoveWindowClients();
   EXPECT_FALSE(Register(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterExistingFailsWithoutWindow) {
   EXPECT_TRUE(Register(sync_options_1_));
   RemoveWindowClients();
   EXPECT_FALSE(Register(sync_options_1_));
 }
 
+TEST_F(BackgroundSyncManagerTest, RegisterSucceedsFromUncontrolledWindow) {
+  RemoveWindowClients();
+  EXPECT_TRUE(RegisterFromDocumentWithServiceWorkerId(sw_registration_id_1_,
+                                                      sync_options_1_));
+}
+
 TEST_F(BackgroundSyncManagerTest, UnregisterSucceedsWithoutWindow) {
   EXPECT_TRUE(Register(sync_options_1_));
   RemoveWindowClients();
   EXPECT_TRUE(Unregister(callback_registration_));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 }  // namespace content