[BackgroundSync] Only allow SyncManager.register to occur from main frame

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/metrics/field_trial.h"
@@ skipping 21 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 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 kProviderId1 = 1;
-const int kProviderId2 = 2;
 
 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;
 }
@@ skipping 140 matching lines @@
   void set_delay_backend(bool delay_backend) { delay_backend_ = delay_backend; }
   void set_one_shot_callback(const OneShotCallback& callback) {
     one_shot_callback_ = callback;
   }
 
   base::Closure delayed_task() const { return delayed_task_; }
   base::TimeDelta delayed_task_delta() const { return delayed_task_delta_; }
 
   BackgroundSyncEventLastChance last_chance() const { return last_chance_; }
 
+  void set_has_main_frame_provider_host(bool value) {
+    has_main_frame_provider_host_ = value;
+  }
+
  protected:
   void StoreDataInBackend(
       int64 sw_registration_id,
       const GURL& origin,
       const std::string& key,
       const std::string& data,
       const ServiceWorkerStorage::StatusCallback& callback) override {
     EXPECT_TRUE(continuation_.is_null());
     if (corrupt_backend_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 40 matching lines @@
     last_chance_ = last_chance;
     one_shot_callback_.Run(active_version, callback);
   }
 
   void ScheduleDelayedTask(const base::Closure& callback,
                            base::TimeDelta delay) override {
     delayed_task_ = callback;
     delayed_task_delta_ = delay;
   }
 
+  void HasMainFrameProviderHost(const GURL& origin,
+                                const BoolCallback& callback) override {
+    callback.Run(has_main_frame_provider_host_);
+  }
+
  private:
   bool corrupt_backend_ = false;
   bool delay_backend_ = false;
+  bool has_main_frame_provider_host_ = true;
   BackgroundSyncEventLastChance last_chance_ =
       BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_NOT_LAST_CHANCE;
   base::Closure continuation_;
   OneShotCallback one_shot_callback_;
   base::Closure delayed_task_;
   base::TimeDelta delayed_task_delta_;
 };
 
 class BackgroundSyncManagerTest : public testing::Test {
  public:
@@ skipping 64 matching lines @@
                    &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);
 
-    // Register window clients for the service workers
-    ServiceWorkerProviderHost* host_1 = new ServiceWorkerProviderHost(
-        helper_->mock_render_process_id(),
-        MSG_ROUTING_NONE /* render_frame_id */, kProviderId1,
-        SERVICE_WORKER_PROVIDER_FOR_WINDOW, helper_->context()->AsWeakPtr(),
-        nullptr);
-    host_1->SetDocumentUrl(GURL(kPattern1));
-
-    ServiceWorkerProviderHost* host_2 = new ServiceWorkerProviderHost(
-        helper_->mock_render_process_id(),
-        MSG_ROUTING_NONE /* render_frame_id */, kProviderId2,
-        SERVICE_WORKER_PROVIDER_FOR_WINDOW, helper_->context()->AsWeakPtr(),
-        nullptr);
-    host_2->SetDocumentUrl(GURL(kPattern2));
-
-    helper_->context()->AddProviderHost(make_scoped_ptr(host_1));
-    helper_->context()->AddProviderHost(make_scoped_ptr(host_2));
-
     // Hang onto the registrations as they need to be "live" when
     // calling BackgroundSyncManager::Register.
     helper_->context_wrapper()->FindReadyRegistrationForId(
         sw_registration_id_1_, GURL(kPattern1).GetOrigin(),
         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_));
 
     helper_->context_wrapper()->FindReadyRegistrationForId(
         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 RemoveWindowClients() {
-    helper_->context()->RemoveAllProviderHostsForProcess(
-        helper_->mock_render_process_id());
-  }
-
   void SetNetwork(net::NetworkChangeNotifier::ConnectionType connection_type) {
     net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
         connection_type);
     if (test_background_sync_manager_) {
       BackgroundSyncNetworkObserver* network_observer =
           test_background_sync_manager_->GetNetworkObserverForTesting();
       network_observer->NotifyManagerIfNetworkChangedForTesting(
           connection_type);
       base::RunLoop().RunUntilIdle();
     }
@@ skipping 67 matching lines @@
   }
 
   void SetupDelayedBackgroundSyncManager() {
     CreateBackgroundSyncManager();
     test_background_sync_manager_->set_delay_backend(true);
     InitBackgroundSyncManager();
   }
 
   void DeleteBackgroundSyncManager() {
     ClearRegistrationHandles();
-    RemoveWindowClients();
     background_sync_manager_.reset();
     test_background_sync_manager_ = nullptr;
     test_clock_ = nullptr;
   }
 
   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
   }
 
   bool RegisterWithServiceWorkerId(
@@ skipping 153 matching lines @@
 
     EXPECT_TRUE(Register(sync_options));
 
     EXPECT_EQ(sync_events_called + 1, sync_events_called_);
     EXPECT_TRUE(GetRegistration(sync_options_1_));
     EXPECT_FALSE(sync_fired_callback_.is_null());
   }
 
   void DeleteServiceWorkerAndStartOver() {
     helper_->context()->ScheduleDeleteAndStartOver();
-    RemoveWindowClients();
     base::RunLoop().RunUntilIdle();
   }
 
   int MaxTagLength() const { return BackgroundSyncManager::kMaxTagLength; }
 
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   TestPowerSource* power_monitor_source_ = nullptr;  // owned by power_monitor_
   scoped_ptr<base::PowerMonitor> power_monitor_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
@@ skipping 1036 matching lines @@
 
   RegisterAndVerifySyncEventDelayed(sync_options_1_);
 
   // Create a new manager which should fire the sync again on init.
   SetupBackgroundSyncManager();
   InitSyncEventTest();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(2, sync_events_called_);
 }
 
-TEST_F(BackgroundSyncManagerTest, RegisterWithClientWindowForWrongOrigin) {
-  RemoveWindowClients();
-  ServiceWorkerProviderHost* host = new ServiceWorkerProviderHost(
-      helper_->mock_render_process_id(), MSG_ROUTING_NONE /* render_frame_id */,
-      kProviderId1, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-      helper_->context()->AsWeakPtr(), nullptr);
-  host->SetDocumentUrl(GURL("http://example.com:9999"));
-  helper_->context()->AddProviderHost(make_scoped_ptr(host));
+TEST_F(BackgroundSyncManagerTest, RegisterFromServiceWorkerWithoutMainFrame) {
+  test_background_sync_manager_->set_has_main_frame_provider_host(false);
   EXPECT_FALSE(Register(sync_options_1_));
+}
+
+TEST_F(BackgroundSyncManagerTest,
+       RegisterFromDocumentWithoutMainFrameProviderHost) {
+  test_background_sync_manager_->set_has_main_frame_provider_host(false);
   EXPECT_TRUE(RegisterFromDocumentWithServiceWorkerId(sw_registration_id_1_,
                                                       sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, RegisterWithNoClientWindows) {
-  RemoveWindowClients();
+TEST_F(BackgroundSyncManagerTest,
+       RegisterExistingFromServiceWorkerWithoutMainFrame) {
+  EXPECT_TRUE(Register(sync_options_1_));
+  test_background_sync_manager_->set_has_main_frame_provider_host(false);
   EXPECT_FALSE(Register(sync_options_1_));
-  EXPECT_TRUE(RegisterFromDocumentWithServiceWorkerId(sw_registration_id_1_,
-                                                      sync_options_1_));
 }
 
-TEST_F(BackgroundSyncManagerTest, RegisterExistingWithNoClientWindows) {
+TEST_F(BackgroundSyncManagerTest, UnregisterSucceedsWithoutMainFrame) {
   EXPECT_TRUE(Register(sync_options_1_));
-  RemoveWindowClients();
-  EXPECT_FALSE(Register(sync_options_1_));
-  EXPECT_TRUE(RegisterFromDocumentWithServiceWorkerId(sw_registration_id_1_,
-                                                      sync_options_1_));
-}
-
-TEST_F(BackgroundSyncManagerTest, UnregisterSucceedsWithoutWindow) {
-  EXPECT_TRUE(Register(sync_options_1_));
-  RemoveWindowClients();
+  test_background_sync_manager_->set_has_main_frame_provider_host(false);
   EXPECT_TRUE(Unregister(callback_registration_handle_.get()));
   EXPECT_FALSE(GetRegistration(sync_options_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, FieldTrialDisablesManager) {
   EXPECT_TRUE(Register(sync_options_1_));
 
   base::FieldTrialList field_trial_list(new base::MockEntropyProvider());
   base::FieldTrialList::CreateFieldTrial("BackgroundSync",
                                          "ExperimentDisabled");
@@ skipping 232 matching lines @@
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content