[BackgroundSyncManager] Remove origin argument from public BackgroundSyncManager methods

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/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
-const char kOrigin[] = "https://example.com";
 const char kPattern1[] = "https://example.com/a";
 const char kPattern2[] = "https://example.com/b";
 const char kScript1[] = "https://example.com/a/script.js";
 const char kScript2[] = "https://example.com/b/script.js";
 const int kRenderProcessId = 99;
 
 void RegisterServiceWorkerCallback(bool* called,
                                    int64* store_registration_id,
                                    ServiceWorkerStatusCode status,
                                    const std::string& status_message,
                                    int64 registration_id) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *called = true;
   *store_registration_id = registration_id;
 }
 
+void FindServiceWorkerRegistrationCallback(
+    scoped_refptr<ServiceWorkerRegistration>* out_registration,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
+  *out_registration = registration;
+}
+
 void UnregisterServiceWorkerCallback(bool* called,
                                      ServiceWorkerStatusCode code) {
   EXPECT_EQ(SERVICE_WORKER_OK, code);
   *called = true;
 }
 
 }  // namespace
 
 // A BackgroundSyncManager that can simulate delaying and corrupting the
 // backend. This class assumes (and verifies) that only one operation runs at a
@@ skipping 98 matching lines @@
   void SetUp() override {
     helper_.reset(
         new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
 
     background_sync_manager_ =
         BackgroundSyncManager::Create(helper_->context_wrapper());
 
     // Wait for storage to finish initializing before registering service
     // workers.
     base::RunLoop().RunUntilIdle();
+    RegisterServiceWorkers();
+  }
 
+  void RegisterServiceWorkers() {
     bool called_1 = false;
     bool called_2 = false;
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern1), GURL(kScript1), NULL,
         base::Bind(&RegisterServiceWorkerCallback, &called_1,
                    &sw_registration_id_1_));
 
     helper_->context()->RegisterServiceWorker(
         GURL(kPattern2), GURL(kScript2), NULL,
         base::Bind(&RegisterServiceWorkerCallback, &called_2,
                    &sw_registration_id_2_));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called_1);
     EXPECT_TRUE(called_2);
+
+    // Hang onto the registrations as they need to be "live" when
+    // calling BackgroundSyncMasnager::Register.

[jsbell, 2015/04/28 20:52:33]

Typo: "Masnager"

+    helper_->context_wrapper()->FindRegistrationForId(
+        sw_registration_id_1_, GURL(kPattern1).GetOrigin(),
+        base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_));
+
+    helper_->context_wrapper()->FindRegistrationForId(
+        sw_registration_id_2_, GURL(kPattern1).GetOrigin(),
+        base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_));
+    base::RunLoop().RunUntilIdle();
+    EXPECT_TRUE(sw_registration_1_);
+    EXPECT_TRUE(sw_registration_2_);
   }
 
   void StatusAndRegistrationCallback(
       bool* was_called,
       BackgroundSyncManager::ErrorType error,
       const BackgroundSyncManager::BackgroundSyncRegistration& registration) {
     *was_called = true;
     callback_error_ = error;
     callback_registration_ = registration;
   }
@@ skipping 18 matching lines @@
     return RegisterWithServiceWorkerId(sw_registration_id_1_,
                                        sync_registration);
   }
 
   bool RegisterWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncManager::BackgroundSyncRegistration&
           sync_registration) {
     bool was_called = false;
     background_sync_manager_->Register(
-        GURL(kOrigin), sw_registration_id, sync_registration,
+        sw_registration_id, sync_registration,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK;
   }
 
   bool Unregister(const BackgroundSyncManager::BackgroundSyncRegistration&
                       sync_registration) {
     return UnregisterWithServiceWorkerId(sw_registration_id_1_,
                                          sync_registration);
   }
 
   bool UnregisterWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncManager::BackgroundSyncRegistration&
           sync_registration) {
     bool was_called = false;
     background_sync_manager_->Unregister(
-        GURL(kOrigin), sw_registration_id, sync_registration.tag,
+        sw_registration_id, sync_registration.tag,
         sync_registration.periodicity, sync_registration.id,
         base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK;
   }
 
   bool GetRegistration(const BackgroundSyncManager::BackgroundSyncRegistration&
                            sync_registration) {
     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
                                               sync_registration);
   }
 
   bool GetRegistrationWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncManager::BackgroundSyncRegistration&
           sync_registration) {
     bool was_called = false;
     background_sync_manager_->GetRegistration(
-        GURL(kOrigin), sw_registration_id, sync_registration.tag,
+        sw_registration_id, sync_registration.tag,
         sync_registration.periodicity,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK) {
       EXPECT_STREQ(sync_registration.tag.c_str(),
                    callback_registration_.tag.c_str());
     }
@@ skipping 19 matching lines @@
                 sw_id == sw_registration_id_2_);
     return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2);
   }
 
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_ptr<BackgroundSyncManager> background_sync_manager_;
 
   int64 sw_registration_id_1_;
   int64 sw_registration_id_2_;
+  scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
+  scoped_refptr<ServiceWorkerRegistration> sw_registration_2_;
 
   BackgroundSyncManager::BackgroundSyncRegistration sync_reg_1_;
   BackgroundSyncManager::BackgroundSyncRegistration sync_reg_2_;
 
   // Callback values.
   BackgroundSyncManager::ErrorType callback_error_;
   BackgroundSyncManager::BackgroundSyncRegistration callback_registration_;
   ServiceWorkerStatusCode callback_sw_status_code_;
 };
 
 TEST_F(BackgroundSyncManagerTest, Register) {
   EXPECT_TRUE(Register(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) {
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_STREQ(sync_reg_1_.tag.c_str(), callback_registration_.tag.c_str());
   EXPECT_NE(
       BackgroundSyncManager::BackgroundSyncRegistration::kInvalidRegistrationId,
       callback_registration_.id);
 }
 
+TEST_F(BackgroundSyncManagerTest, RegisterWithoutLiveSWRegistration) {
+  sw_registration_1_ = nullptr;
+  EXPECT_FALSE(Register(sync_reg_1_));
+  EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_NO_SERVICE_WORKER,
+            callback_error_);
+}
+
+TEST_F(BackgroundSyncManagerTest, RegisterWithoutActiveSWRegistration) {
+  sw_registration_1_->UnsetVersion(sw_registration_1_->active_version());
+  EXPECT_FALSE(Register(sync_reg_1_));
+  EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_NO_SERVICE_WORKER,
+            callback_error_);
+}
+
 TEST_F(BackgroundSyncManagerTest, RegisterExistingKeepsId) {
   EXPECT_TRUE(Register(sync_reg_1_));
   BackgroundSyncManager::BackgroundSyncRegistration first_registration =
       callback_registration_;
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(callback_registration_.Equals(first_registration));
   EXPECT_EQ(first_registration.id, callback_registration_.id);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterOverwrites) {
@@ skipping 176 matching lines @@
   manager->set_delay_backend(true);
   manager->DoInit();
 
   const int64 kExpectedInitialId =
       BackgroundSyncManager::BackgroundSyncRegistration::kInitialId;
 
   bool register_called = false;
   bool unregister_called = false;
   bool get_registration_called = false;
   manager->Register(
-      GURL(kOrigin), sw_registration_id_1_, sync_reg_1_,
+      sw_registration_id_1_, sync_reg_1_,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &register_called));
-  manager->Unregister(GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.tag,
+  manager->Unregister(sw_registration_id_1_, sync_reg_1_.tag,
                       sync_reg_1_.periodicity, kExpectedInitialId,
                       base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                                  base::Unretained(this), &unregister_called));
   manager->GetRegistration(
-      GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.tag,
-      sync_reg_1_.periodicity,
+      sw_registration_id_1_, sync_reg_1_.tag, sync_reg_1_.periodicity,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &get_registration_called));
 
   base::RunLoop().RunUntilIdle();
   // Init should be blocked while loading from the backend.
   EXPECT_FALSE(register_called);
   EXPECT_FALSE(unregister_called);
   EXPECT_FALSE(get_registration_called);
 
   manager->Continue();
@@ skipping 32 matching lines @@
   TestBackgroundSyncManager* manager =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->DoInit();
 
   EXPECT_TRUE(Register(sync_reg_1_));
 
   manager->set_delay_backend(true);
   bool callback_called = false;
   manager->Register(
-      GURL(kOrigin), sw_registration_id_1_, sync_reg_2_,
+      sw_registration_id_1_, sync_reg_2_,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &callback_called));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_called);
   UnregisterServiceWorker(sw_registration_id_1_);
 
   manager->Continue();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_called);
@@ skipping 40 matching lines @@
   EXPECT_TRUE(Register(sync_reg_1_));
   manager->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_reg_2_));
 
   // The manager is now disabled and not accepting new requests until browser
   // restart or notification that the storage has been wiped.
   manager->set_corrupt_backend(false);
   helper_->context()->ScheduleDeleteAndStartOver();
   base::RunLoop().RunUntilIdle();
 
-  bool called = false;
-  helper_->context()->RegisterServiceWorker(
-      GURL(kPattern1), GURL(kScript1), NULL,
-      base::Bind(&RegisterServiceWorkerCallback, &called,
-                 &sw_registration_id_1_));
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(called);
+  RegisterServiceWorkers();
 
   EXPECT_TRUE(Register(sync_reg_2_));
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_TRUE(GetRegistration(sync_reg_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsId) {
   BackgroundSyncManager::BackgroundSyncRegistration reg_1;
   BackgroundSyncManager::BackgroundSyncRegistration reg_2;
 
@@ skipping 97 matching lines @@
   EXPECT_TRUE(Unregister(callback_registration_));
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_TRUE(GetRegistration(sync_reg_2_));
   EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.periodicity);
 
   EXPECT_TRUE(Unregister(callback_registration_));
   EXPECT_FALSE(GetRegistration(sync_reg_2_));
 }
 
 }  // namespace content