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

content/browser/background_sync/background_sync_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 #define CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 26 matching lines @@
 
 // BackgroundSyncManager manages and stores the set of background sync
 // registrations across all registered service workers for a profile.
 // Registrations are stored along with their associated Service Worker
 // registration in ServiceWorkerStorage. If the ServiceWorker is unregistered,
 // the sync registrations are removed. This class must be run on the IO
 // thread. The asynchronous methods are executed sequentially.
 class CONTENT_EXPORT BackgroundSyncManager
     : NON_EXPORTED_BASE(public ServiceWorkerContextObserver) {
  public:
+  using BoolCallback = base::Callback<void(bool)>;
   using StatusCallback = base::Callback<void(BackgroundSyncStatus)>;
   using StatusAndRegistrationCallback =
       base::Callback<void(BackgroundSyncStatus,
                           scoped_ptr<BackgroundSyncRegistrationHandle>)>;
   using StatusAndStateCallback =
       base::Callback<void(BackgroundSyncStatus, BackgroundSyncState)>;
   using StatusAndRegistrationsCallback = base::Callback<void(
       BackgroundSyncStatus,
       scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>)>;
 
@@ skipping 82 matching lines @@
       const std::string& backend_key,
       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
           callback);
   virtual void FireOneShotSync(
       BackgroundSyncRegistrationHandle::HandleId handle_id,
       const scoped_refptr<ServiceWorkerVersion>& active_version,
       BackgroundSyncEventLastChance last_chance,
       const ServiceWorkerVersion::StatusCallback& callback);
   virtual void ScheduleDelayedTask(const base::Closure& callback,
                                    base::TimeDelta delay);
+  virtual void HasMainFrameProviderHost(const GURL& origin,
+                                        const BoolCallback& callback);
 
  private:
   friend class BackgroundSyncManagerTest;
   friend class BackgroundSyncRegistrationHandle;
 
   class RegistrationKey {
    public:
     explicit RegistrationKey(const BackgroundSyncRegistration& registration);
     explicit RegistrationKey(const BackgroundSyncRegistrationOptions& options);
     RegistrationKey(const std::string& tag, SyncPeriodicity periodicity);
@@ skipping 72 matching lines @@
       const GURL& origin,
       const scoped_refptr<RefCountedRegistration>& sync_registration);
 
   void InitImpl(const base::Closure& callback);
   void InitDidGetDataFromBackend(
       const base::Closure& callback,
       const std::vector<std::pair<int64, std::string>>& user_data,
       ServiceWorkerStatusCode status);
 
   // Register callbacks
+  void RegisterCheckIfMainFrame(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistrationOptions& options,
+      const StatusAndRegistrationCallback& callback);
+  void RegisterDidCheckIfMainFrame(
+      int64 sw_registration_id,
+      const BackgroundSyncRegistrationOptions& options,
+      const StatusAndRegistrationCallback& callback,
+      bool has_main_frame_client);
   void RegisterImpl(int64 sw_registration_id,
                     const BackgroundSyncRegistrationOptions& options,
-                    bool requested_from_service_worker,
                     const StatusAndRegistrationCallback& callback);
   void RegisterDidStore(
       int64 sw_registration_id,
       const scoped_refptr<RefCountedRegistration>& new_registration_ref,
       const StatusAndRegistrationCallback& callback,
       ServiceWorkerStatusCode status);
 
   // Removes the background sync with periodicity |periodicity| and id
   // |sync_registration_id|. Calls |callback| with
   // BACKGROUND_SYNC_STATUS_NOT_FOUND if no match is found. Calls |callback|
@@ skipping 131 matching lines @@
   scoped_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_