[BackgroundSync Cleanup] Remove periodic sync code

content/browser/background_sync/background_sync_service_impl.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_service_impl.h"
 
 #include <utility>
 
 #include "background_sync_registration_handle.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "content/browser/background_sync/background_sync_context_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 
 // TODO(iclelland): Move these converters to mojo::TypeConverter template
 // specializations.
 
 BackgroundSyncRegistrationOptions ToBackgroundSyncRegistrationOptions(
     const SyncRegistrationPtr& in) {
   BackgroundSyncRegistrationOptions out;
 
   out.tag = in->tag;
-  out.min_period = in->min_period_ms;
   out.network_state = static_cast<SyncNetworkState>(in->network_state);
-  out.periodicity = static_cast<SyncPeriodicity>(in->periodicity);
   return out;
 }
 
 SyncRegistrationPtr ToMojoRegistration(
     const BackgroundSyncRegistrationHandle& in) {
   SyncRegistrationPtr out(content::SyncRegistration::New());
   out->handle_id = in.handle_id();
   out->tag = in.options()->tag;
-  out->min_period_ms = in.options()->min_period;
-  out->periodicity = static_cast<content::BackgroundSyncPeriodicity>(
-      in.options()->periodicity);
   out->network_state = static_cast<content::BackgroundSyncNetworkState>(
       in.options()->network_state);
   return out;
 }
 
 }  // namespace
 
 #define COMPILE_ASSERT_MATCHING_ENUM(mojo_name, manager_name) \
   static_assert(static_cast<int>(content::mojo_name) ==       \
                     static_cast<int>(content::manager_name),  \
@@ skipping 15 matching lines @@
 
 COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::ANY,
                              SyncNetworkState::NETWORK_STATE_ANY);
 COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::AVOID_CELLULAR,
                              SyncNetworkState::NETWORK_STATE_AVOID_CELLULAR);
 COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::ONLINE,
                              SyncNetworkState::NETWORK_STATE_ONLINE);
 COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncNetworkState::MAX,
                              SyncNetworkState::NETWORK_STATE_ONLINE);
 
-COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::PERIODIC,
-                             SyncPeriodicity::SYNC_PERIODIC);
-COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::ONE_SHOT,
-                             SyncPeriodicity::SYNC_ONE_SHOT);
-COMPILE_ASSERT_MATCHING_ENUM(BackgroundSyncPeriodicity::MAX,
-                             SyncPeriodicity::SYNC_ONE_SHOT);
-
 BackgroundSyncServiceImpl::~BackgroundSyncServiceImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context_->background_sync_manager());
 }
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
     BackgroundSyncContextImpl* background_sync_context,
     mojo::InterfaceRequest<BackgroundSyncService> request)
     : background_sync_context_(background_sync_context),
       binding_(this, std::move(request)),
@@ skipping 42 matching lines @@
     return;
   }
 
   registration->Unregister(
       sw_registration_id,
       base::Bind(&BackgroundSyncServiceImpl::OnUnregisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetRegistration(
-    BackgroundSyncPeriodicity periodicity,
     const mojo::String& tag,
     int64_t sw_registration_id,
     const GetRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
   background_sync_manager->GetRegistration(
-      sw_registration_id, tag.get(), static_cast<SyncPeriodicity>(periodicity),
+      sw_registration_id, tag.get(),
       base::Bind(&BackgroundSyncServiceImpl::OnRegisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetRegistrations(
-    BackgroundSyncPeriodicity periodicity,
     int64_t sw_registration_id,
     const GetRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
   background_sync_manager->GetRegistrations(
-      sw_registration_id, static_cast<SyncPeriodicity>(periodicity),
+      sw_registration_id,
       base::Bind(&BackgroundSyncServiceImpl::OnGetRegistrationsResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetPermissionStatus(
-    BackgroundSyncPeriodicity periodicity,
     int64_t sw_registration_id,
     const GetPermissionStatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(iclelland): Implement a real policy. This is a stub implementation.
   // OneShot: crbug.com/482091
-  // Periodic: crbug.com/482093
   callback.Run(BackgroundSyncError::NONE, PermissionStatus::GRANTED);
 }
 
 void BackgroundSyncServiceImpl::DuplicateRegistrationHandle(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     const DuplicateRegistrationHandleCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
@@ skipping 91 matching lines @@
 
 void BackgroundSyncServiceImpl::OnNotifyWhenFinishedResult(
     const NotifyWhenFinishedCallback& callback,
     BackgroundSyncStatus status,
     BackgroundSyncState sync_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status), sync_state);
 }
 
 }  // namespace content